Dependency cleanup and performance streamline

Core/Inc/NbusBridge.h

@@ -17,26 +17,27 @@
  */
 #define MAX_SLAVES 16
 
-/** Makro zistí adresu modulu z RX paketu */
-#define MODULE_ADDRESS(packet)  packet[0]
-/** Makro zistí adresu seznora z RX paketu */
-#define SENSOR_ADDRESS(packet)  packet[1]
-/** Makro zistí kód funkcie z RX paketu */
-#define FUNCTION_CODE(packet)   packet[2]
 
-#define DATA0_ADDRESS(packet)   packet[3]
+
+#define ECHO_SCAN_LENGTH	   4
+#define ECHO_SCAN_DATA	       {110, 66, 117, 115} // nBus
+#define ECHO_SCAN_CHAR0		   110
+#define ECHO_SCAN_CHAR1		   66
+#define ECHO_SCAN_CHAR2		   117
+#define ECHO_SCAN_CHAR3		   115
 
 /** Adresa broadcastu */
 #define BROADCAST_ADDRESS	0
 /** Virtuálna adresa modulu nBus Bridge */
 #define BRIDGE_ADDRESS		0xFF
+/** Macro for bridge terminator **/
+#define BRIDGE_TERMINATOR 	0xFF
 
 #define BRIDGE_INFO_VERSION		"1.0"
 #define BRIDGE_INFO_HW_FAMILY	"STM"
 #define BRIDGE_INFO_HW_VERSION	"0.5"
 
-#define PDU_SIZE 3
-#define RX_META	4
+
 
 
 #define DATAPACKET_SIZE  (NBUS_MAX_FRAME_SIZE*MAX_SLAVES)
@@ -56,47 +57,58 @@ typedef enum {
 class NbusBridge {
 
 private:
+
+	uint8_t _crc8x_fast(void const *mem, uint16_t len);
+
 	/** Objekt zabezpečujúci komunikáciu na internej aj externej zbernici nBus */
-	NbusCommunicator *_communicator;
+	NbusCommunicator *_communicator{nullptr};
 	/** Statické pole objektov nBus slave */
 	NbusSlave _slaves[MAX_SLAVES];
 	/** Pole detegovaných adries modulov slave. Pole sa naplní pri automatickom skene internej zbernice */
-	uint8_t _slave_adress[MAX_SLAVES];
+	uint8_t _slave_adress[MAX_SLAVES]{0};
 	/** Počet detegovaných slave zariadení. */
-	uint8_t _num_slaves;
+	uint8_t _num_slaves{0};
 	/** Príznak indikuje, či je modul Bridge v stave RUN */
-	RunState_e _run_state;
+	RunState_e _run_state{STATE_STOPPED};
     /** Interný buffer */
-	DataFrame *_worker_frame_ptr;
+	DataFrame *_worker_frame_ptr{nullptr};
 	/** Pole bajtov použité pre generovanie odpovede pomocou triedy DataFrame */
-	uint8_t _data_packet[DATAPACKET_SIZE];
+	uint8_t _data_packet[DATAPACKET_SIZE]{0};
 	/** Dataframe (wrapper nad _dataPacket), do ktorého za vygeneruje odsielaný packet.*/
-	DataFrame _raw_data_frame;
-	DataFrame _master_frame;
+	DataFrame _raw_data_frame{_data_packet, DATAPACKET_SIZE, TYPE_RAW, CRC_OFF};
+	DataFrame _master_frame{_data_packet, DATAPACKET_SIZE, TYPE_PLAIN, CRC_ON};
 
-	Nbus_pdu _pdu;
+	uint8_t _scan_request{0};
+	Nbus_PDU_t _pdu{BROADCAST_ADDRESS, BROADCAST_ADDRESS, FC_ECHO};
 
 public:
-	NbusBridge();
+
 	/** Nastaví komunikačný modul */
 	void setCommunicator(NbusCommunicator *nc);
-	virtual ~NbusBridge();
 
 	void scan();
 	uint8_t getNumSlaves();
 	NbusSlave * getSlave(uint8_t index);
 
 
-	DataFrame * getBridgeSlaves();
-	DataFrame * getBridgeInfo();
+	DataFrame * bridge_getSlaves();
+	DataFrame * bridge_getInfo();
+	DataFrame * bridge_getData();
+	DataFrame * bridge_setErrResponse(Nbus_EC_e ec);
+
 
 	void processRequest(uint8_t *rxFrame, uint8_t size);
+
+	void process_broadcast(uint8_t *rxFrame);
 	void process_bridge_request(uint8_t *rxFrame, uint8_t size);
 	void process_slave_request(uint8_t *rxFrame, uint8_t size);
+
 	void broadcastStart();
 	void broadcastStop();
 	void processRunningState();
-	void process_broadcast(uint8_t *rxFrame);
+
+
+
 
 };
 

Core/Inc/NbusCommunicator.h

@@ -40,8 +40,12 @@ public:
 
 	virtual ~NbusCommunicator();
 
-	DataFrame* sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
-	void send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len);
+	DataFrame* sendAndReceive(Nbus_PDU_t *pdu, uint8_t *data, uint8_t data_len);
+
+	void sendToSlave(DataFrame *slave_frame);
+
+	DataFrame * sendAndReceiveSlave(DataFrame *slave_frame);
+	void send(Nbus_PDU_t *pdu, uint8_t *data, uint8_t data_len);
 };
 
 

Core/Inc/NbusSlave.h

@@ -1,8 +1,8 @@
 /**
  * @file AppBridge.h
- * @brief Deklarácia modulu nBus Slave z pohľadu nBus Bridge
- * @date Mar 3, 2025
- * @author Juraj Dudak
+ * @brief nBus Slave module declaration.
+ * @date Nov 26, 2025
+ * @author Juraj Dudak, Matus Necas
  */
 #ifndef SRC_APPSLAVE_H_
 #define SRC_APPSLAVE_H_
@@ -12,39 +12,57 @@
 #include "dataframe.h"
 #include "NbusCommunicator.h"
 
-/** Adresa slave modulu, bez špecifikácie adresy konktrétneho senzora. */
-#define SLAVE_ADDRESS_MODULE	0
 
+/** Macro for module-only address. */
+#define SLAVE_ADDRESS_MODULE   0
+
+
+/** Class for nBus slave communication */
 class NbusSlave {
 
 private:
-	NbusCommunicator* _communicator;
-	Nbus_pdu _pdu;
-	uint8_t _sensor_cache[16];
-
-	uint8_t _sensor_count;
+	NbusCommunicator* _communicator{nullptr};	///< hardware bus communicator
+	Nbus_PDU_t _pdu{0, 0, FC_ECHO}; 			///< slave PDU
+	uint8_t _sensor_cache[16]{0};				///< sensor temporary data
+	uint8_t _sensor_count{0};					///< number of sensors
 
 public:
-	NbusSlave(uint8_t, NbusCommunicator*);
-	NbusSlave();
-	virtual ~NbusSlave();
-	void setCommunicator(NbusCommunicator*);
-	void setAddress(uint8_t);
+	/** Set nBus communicator
+	 * @param nbus_comm: communicator to set
+	 */
+	void setCommunicator(NbusCommunicator* nbus_comm);
+
+	/** Set nBus address
+	 * @param addr: address to set
+	 */
+	void setAddress(uint8_t addr);
+
+	/** Get slave active status
+	 * @return: active status (1 = active, 0 = inactive)
+	 */
 	bool isActive();
-	uint8_t getSensorAddress();
+
+	/** Get nBus module address
+     * @return: actual address (0 if not set)
+	 */
 	uint8_t getModuleAddress();
-	DataFrame* nbus_echo(uint8_t *echo_data, uint8_t size);
-	DataFrame* nbus_sensor_count();
-	DataFrame* nbus_sensor_type(uint8_t);
-	DataFrame* nbus_sensor_format(uint8_t);
-	DataFrame* nbus_module_info();
-	DataFrame* nbus_sensor_getData(uint8_t sensor_address);
-	DataFrame* nbus_sensor_parameter(uint8_t, uint8_t);
-	DataFrame* nbus_sensor_parameters(uint8_t);
-	DataFrame* nbus_module_find(void);
-
-	uint8_t nbus_get_sensor_count(bool check_hw = false);
 
+	/** Send nBus request and get sensor count
+	 * @param check_hw: 1 = load from bus, 0 = use local cache
+	 * @return: response data frame
+	 */
+	uint8_t nbusSlaveCmd_getSensorCnt(bool check_hw);
+
+	/** Send any nBus request and get response
+	 * @param slave_frame: data to send
+	 * @return: response data frame
+	 */
+	DataFrame * nbusSlaveCmd_processRequest(DataFrame *slave_frame);
+
+	/** Send nBus request and get sensor data
+	 * @return: response data frame
+	 */
+	DataFrame * nbusSlaveCmd_getData();
 };
 
 

Core/Inc/nbus_structs.h

@@ -1,8 +1,8 @@
 /**
  * @file nbus_structs.h
  *
- *  @date: Mar 7, 2025
- *  @author: Juraj Dudak
+ *  @date: Nov 26, 2025
+ *  @author: Juraj Dudak, Matus Necas
  */
 
 #ifndef INC_NBUS_STRUCTS_H_
@@ -21,7 +21,23 @@
 #include "stm32l0xx_hal.h"
 #endif
 
+/** Macro for module address in RX packet */
+#define MODULE_RX_ADDRESS(packet)	(packet)[0]
+/** Macro for sensor address in RX packet */
+#define SENSOR_RX_ADDRESS(packet)	(packet)[1]
+/** Macro for function code in RX packet */
+#define FUNCTION_RX_CODE(packet)	(packet)[2]
+/** Macro for #0 data byte in RX packet */
+#define DATA0_RX_ADDRESS(packet)	(packet)[3]
+/** Macro for #0 data byte in TX packet */
+#define DATA0_TX_ADDRESS(packet) (packet)[4]
+/** Macro to set error response */
+#define SET_ERR_RESPONSE(fc)	((fc) | 0x80)
+/** Macro for RX meta size in bytes */
+#define RX_META_SIZE	4
 
+
+/** Enumerate for function codes  */
 typedef enum {
 	FC_FIND = 0,
 	FC_ECHO,			/* 1 */
@@ -40,14 +56,41 @@ typedef enum {
 	FC_INFO,			/* 0xE => 14 */
 	FC_SENSOR_FORMAT, 	/* 0xF => 15 */
 	FC_SLAVES,		 	/* 0x10 => 16 */
-}Nbus_FC_e;
+} Nbus_FC_e;
 
 
+/** Structure for PDU data */
 typedef struct {
 	uint8_t ma;
 	uint8_t sa;
 	Nbus_FC_e fc;
-}Nbus_pdu;
+} Nbus_PDU_t;
+
+
+/** Enumerate for error codes  */
+typedef enum {
+	OK_CODE = 0x00,
+	ILLEGAL_FUNCTION = 0x01,
+	ILLEGAL_DEVICE_ADDRESS = 0x02,
+	ILLEGAL_DATA_VALUE = 0x03,
+	SLAVE_DEVICE_FAILURE = 0x04,
+	ACKNOWLEDGE = 0x05,
+	DEVICE_BUSY = 0x06,
+	DEVICE_NOT_READY = 0x07,
+	PARAM_NOT_IMPLEMENTED = 0x10,
+	ILLEGAL_FUNCTION_PARAM = 0x11,
+	DEVICE_IS_READ_ONLY = 0x12,
+	GENERIC_SUBSLAVE_ERROR = 0x13,
+	ERR_SUBSLAVE_INIT_FAIL = 0x14,
+	SUBSLAVE_CUSTOM_ERR_1 = 0x1A,
+	SUBSLAVE_CUSTOM_ERR_2 = 0x1B,
+	SUBSLAVE_CUSTOM_ERR_3 = 0x1C,
+	SUBSLAVE_CUSTOM_ERR_4 = 0x1D,
+	SUBSLAVE_CUSTOM_ERR_5 = 0x1E,
+	SUBSLAVE_CUSTOM_ERR_6 = 0x1F,
+	ERR_OUTPUT_ONLY = 0x21,
+	ERR_INPUT_ONLY = 0x22
+} Nbus_EC_e;
 
 
 

Core/Src/AppBridge.cpp

@@ -100,7 +100,7 @@ void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
             vMasterUartSize = 0;
             vMasterUartIndex = 0;
             pMasterUartRx[0] = 0;
-            if (MODULE_ADDRESS(pMasterUartFrame) == 0)
+            if (MODULE_RX_ADDRESS(pMasterUartFrame) == 0)
             {
                 bridge.process_broadcast(pMasterUartFrame);
                 // TODO tu este mozno deaktivovat spracovanie broadcast paketu

Core/Src/NbusBridge.cpp

@@ -7,9 +7,8 @@
 
 #include "NbusBridge.h"
 
-volatile uint8_t scan_request = 0;
 
-static uint8_t const crc8x_table[] = {
+static const uint8_t __crc8x_table[] = {
     0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D, 0x70, 0x77, 0x7E,
     0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D, 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB,
     0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD, 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8,
@@ -25,32 +24,21 @@ static uint8_t const crc8x_table[] = {
     0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83, 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC,
     0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3};
 
-static uint8_t crc8x_fast(void const *mem, uint16_t len)
+uint8_t NbusBridge::_crc8x_fast(void const *mem, uint16_t len)
 {
     uint8_t crc = 0;
     uint8_t const *data = (uint8_t *)mem;
-    if (data == NULL)
+    if (data == nullptr)
         return 0xff;
     crc &= 0xff;
     while (len--)
-        crc = crc8x_table[crc ^ *data++];
+        crc = __crc8x_table[crc ^ *data++];
     return crc;
 }
 
-NbusBridge::NbusBridge()
-: _raw_data_frame(_data_packet, DATAPACKET_SIZE, TYPE_RAW, CRC_OFF),
-  _master_frame(_data_packet, DATAPACKET_SIZE, TYPE_PLAIN, CRC_ON)
-{
-
-    _communicator = NULL;
-    _num_slaves = 0;
-    _run_state = STATE_STOPPED;
-    _pdu.sa = BROADCAST_ADDRESS;
-}
-
 void NbusBridge::setCommunicator(NbusCommunicator *nc)
 {
-    if (nc == NULL)
+    if (nc == nullptr)
     {
         while (1)
         {
@@ -64,10 +52,6 @@ void NbusBridge::setCommunicator(NbusCommunicator *nc)
     _pdu.sa = BROADCAST_ADDRESS;
 }
 
-NbusBridge::~NbusBridge()
-{
-    // empty
-}
 
 /**
  * Spustí scan internej nbus siete.
@@ -77,17 +61,14 @@ NbusBridge::~NbusBridge()
 void NbusBridge::scan()
 {
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
+
     _num_slaves = 0;
 
-    DataFrame *frame;
-    uint8_t *response;
-    Nbus_pdu pdu;
-    pdu.fc = FC_ECHO;
-    pdu.sa = SLAVE_ADDRESS_MODULE;
-    _pdu.ma = SLAVE_ADDRESS_MODULE;
-    uint8_t data[4] = {110, 66, 117, 115}; // nBus
-    const uint8_t data_offset = 4;
-    uint8_t slave_index = 0;
+    DataFrame *response_frame;
+    uint8_t   *response_raw;
+    Nbus_PDU_t   pdu = {SLAVE_ADDRESS_MODULE, SLAVE_ADDRESS_MODULE, FC_ECHO};
+    uint8_t    data[] = ECHO_SCAN_DATA;
+    uint8_t    slave_index = 0;
 
     for (uint32_t i = 1; i < MAX_SLAVES; i++)
     {
@@ -98,17 +79,20 @@ void NbusBridge::scan()
     {
         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_3);
         pdu.ma = i;
-        frame = _communicator->sendAndReceive(&pdu, data, 4);
-        if (!frame->IsEmpty())
+        response_frame = _communicator->sendAndReceive(&pdu, data, ECHO_SCAN_LENGTH);
+
+        if (!response_frame->IsEmpty())
         {
-            response = frame->GetFrame();
-            if (response[0 + data_offset] == 110 && response[1 + data_offset] == 66 &&
-                response[2 + data_offset] == 117 && response[3 + data_offset] == 115)
+            response_raw = response_frame->GetFrame();
+
+            if (DATA0_TX_ADDRESS(response_raw + 0) == ECHO_SCAN_CHAR0 && DATA0_TX_ADDRESS(response_raw + 1) == ECHO_SCAN_CHAR1 &&
+            	DATA0_TX_ADDRESS(response_raw + 2) == ECHO_SCAN_CHAR2 && DATA0_TX_ADDRESS(response_raw + 3) == ECHO_SCAN_CHAR3)
             {
                 _num_slaves++;
                 _slaves[i].setAddress(i);
                 _slaves[i].setCommunicator(_communicator);
                 _slave_adress[slave_index++] = i;
+                _slaves[i].nbusSlaveCmd_getSensorCnt(true); 	// retrieve sensor count for each slave
             }
         }
     }
@@ -129,7 +113,8 @@ NbusSlave *NbusBridge::getSlave(uint8_t index)
             return &_slaves[index];
         }
     }
-    return NULL;
+
+    return nullptr;
 }
 
 /**
@@ -148,7 +133,7 @@ void NbusBridge::broadcastStart()
 {
     _pdu.fc = FC_START;
     _pdu.ma = BROADCAST_ADDRESS;
-    _communicator->send(&_pdu, NULL, 0);
+    _communicator->send(&_pdu, nullptr, 0);
     _run_state = STATE_RUNNING;
 }
 
@@ -159,7 +144,7 @@ void NbusBridge::broadcastStop()
 {
     _pdu.fc = FC_STOP;
     _pdu.ma = BROADCAST_ADDRESS;
-    _communicator->send(&_pdu, NULL, 0);
+    _communicator->send(&_pdu, nullptr, 0);
     _run_state = STATE_TO_STOP;
 }
 
@@ -171,7 +156,7 @@ void NbusBridge::broadcastStop()
  */
 void NbusBridge::process_broadcast(uint8_t *rxFrame)
 {
-    switch (FUNCTION_CODE(rxFrame))
+    switch (FUNCTION_RX_CODE(rxFrame))
     {
 
     case FC_STOP: /* 2 */
@@ -200,166 +185,136 @@ void NbusBridge::process_broadcast(uint8_t *rxFrame)
  */
 void NbusBridge::process_bridge_request(uint8_t *rxFrame, uint8_t size)
 {
-	_master_frame.Init();
-	_master_frame.AddArray(rxFrame, PDU_SIZE);
-
-	switch (FUNCTION_CODE(rxFrame))
+	switch (FUNCTION_RX_CODE(rxFrame))
     {
     case FC_ECHO: /* 1 */
-    	_master_frame.AddArray(&DATA0_ADDRESS(rxFrame), size  - RX_META);
+    	_master_frame.AddArray(&DATA0_RX_ADDRESS(rxFrame), size  - RX_META_SIZE);
         break;
 
     case FC_RESET: /* 9 */
-    {
-        scan_request = 1;
+	{
+        _scan_request = 1;
         // send same frame back
-    	_master_frame.AddArray(&DATA0_ADDRESS(rxFrame), size  - RX_META);
+    	_master_frame.AddArray(&DATA0_RX_ADDRESS(rxFrame), size  - RX_META_SIZE);
     }
     break;
 
+    case FC_DATA: /* 11 */
+    	_worker_frame_ptr = bridge_getData();
+    	break;
+
     case FC_INFO: /* 0xE => 15 */
-    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
-    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
-    	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
+    	_worker_frame_ptr = bridge_getInfo();
         break;
 
     case FC_SLAVES: /* 0x10 => 16 */
-    	for (uint8_t i = 0; i < _num_slaves; i++)
-    	{
-    		_master_frame.AddInt8(i + 1);
-    		_master_frame.AddInt8(_slave_adress[i]);
-    	}
+       	_worker_frame_ptr = bridge_getSlaves();
         break;
 
-    default:; // nothing
+    default:
+      	_worker_frame_ptr = bridge_setErrResponse(ILLEGAL_FUNCTION);
     }
 
-    _master_frame.Commit();
-	_communicator->sendToMaster(&_master_frame);
+	_communicator->sendToMaster(_worker_frame_ptr);
 }
 
 void NbusBridge::process_slave_request(uint8_t *rxFrame, uint8_t size)
 {
-    uint8_t send_reponse = 1;
-
-    NbusSlave *selected_slave = getSlave(MODULE_ADDRESS(rxFrame));
-    if (selected_slave == NULL)
-    {
-        return;
-    }
+    NbusSlave *selected_slave = getSlave(MODULE_RX_ADDRESS(rxFrame));
 
-    if (!selected_slave->isActive())
+    if (selected_slave == nullptr)
     {
-        return;
+    	_worker_frame_ptr = bridge_setErrResponse(ILLEGAL_DEVICE_ADDRESS);
     }
 
-    switch (FUNCTION_CODE(rxFrame))
-    {
-
-    case FC_FIND: /* 0 */
-        _worker_frame_ptr = selected_slave->nbus_module_find();
-        break;
-
-    case FC_ECHO: /* 1 */
-    	_worker_frame_ptr = selected_slave->nbus_echo(&DATA0_ADDRESS(rxFrame), size - RX_META);
-        break;
-
-    case FC_PARAM: /* 4 */
-        if (size == RX_META)
-        {
-        	_worker_frame_ptr = selected_slave->nbus_sensor_parameters(SENSOR_ADDRESS(rxFrame));
-        }
-        else
-        {
-        	_worker_frame_ptr = selected_slave->nbus_sensor_parameter(SENSOR_ADDRESS(rxFrame), rxFrame[RX_META - 1]);
-        }
-        break;
-
-    case FC_SENSOR_CNT: /* 5 */
-    	_worker_frame_ptr = selected_slave->nbus_sensor_count();
-        break;
-
-    case FC_SLEEP: /* 6 */
-        break;
-
-    case FC_WAKEUP: /* 7 */
-        break;
-
-    case FC_CALIBRATE: /* 8 */
-        break;
-
-    case FC_RESET: /* 9 */
-        break;
-
-    case FC_STORE: /* 0xA => 10 */
-        break;
-
-    case FC_DATA: /* 0xB => 11  Get data from specific slave, Unicast mode */
-    	_worker_frame_ptr = selected_slave->nbus_sensor_getData(SENSOR_ADDRESS(rxFrame));
-        break;
+    _raw_data_frame.Init();
+    _raw_data_frame.AddUint8(size);
+    _raw_data_frame.AddArray(rxFrame, size);
+    _raw_data_frame.Commit();
 
-    case FC_SYNC: /* 0xC => 12 */
-        break;
+    _worker_frame_ptr = selected_slave->nbusSlaveCmd_processRequest(&_raw_data_frame);
+    _communicator->sendToMaster(_worker_frame_ptr);
+}
 
-    case FC_SENSOR_TYPE: /* 0xD => 13 */
-    	_worker_frame_ptr = selected_slave->nbus_sensor_type(SENSOR_ADDRESS(rxFrame));
-        break;
+/**
+ * Pripraví informáciu o všetkcýh nBus slave moduloch
+ */
+DataFrame* NbusBridge::bridge_getSlaves()
+{
+	_master_frame.Init();
+	_master_frame.AddUint8(BROADCAST_ADDRESS);
+	_master_frame.AddUint8(BRIDGE_ADDRESS);
+	_master_frame.AddUint8(FC_SLAVES);
 
-    case FC_INFO: /* 0xE => 14 */
-    	_worker_frame_ptr = selected_slave->nbus_module_info();
-        break;
+	for (uint8_t i = 0; i < _num_slaves; i++)
+    {
+		_master_frame.AddInt8(i + 1);
+		_master_frame.AddInt8(_slave_adress[i]);
+    }
 
-    case FC_SENSOR_FORMAT: /* 0xF => 15 */
-    	_worker_frame_ptr = selected_slave->nbus_sensor_format(SENSOR_ADDRESS(rxFrame));
-        break;
+	_master_frame.Commit();
 
-    default:
-        send_reponse = 0;
-    }
+	return &_master_frame;
+}
 
-    if (send_reponse == 1)
-    {
-        _communicator->sendToMaster(_worker_frame_ptr);
-    }
+DataFrame * NbusBridge::bridge_getInfo()
+{
+	_master_frame.Init();
+	_master_frame.AddUint8(BROADCAST_ADDRESS);
+	_master_frame.AddUint8(BRIDGE_ADDRESS);
+	_master_frame.AddUint8(FC_INFO);
+	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
+	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
+	_master_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
+	_master_frame.Commit();
+
+	return &_master_frame;
 }
 
-/**
- * Pripraví informáciu o všetkcýh nBus slave moduloch
- */
-DataFrame* NbusBridge::getBridgeSlaves()
+DataFrame * NbusBridge::bridge_getData()
 {
+	NbusSlave * slave_ptr = nullptr;
+
 	_raw_data_frame.Init();
+	_raw_data_frame.AddHeader(TYPE_HEADER_2B);
+	_raw_data_frame.AddInt32(HAL_GetTick());
 
-	for (uint8_t i = 0; i < _num_slaves; i++)
+	for (uint32_t i = 0; i < _num_slaves; i++)
 	{
-		_raw_data_frame.AddInt8(i + 1);
-		_raw_data_frame.AddInt8(_slave_adress[i]);
+		slave_ptr = getSlave(_slave_adress[i]);
+		if (slave_ptr != nullptr)
+		{
+			_raw_data_frame.AddInt8(slave_ptr->getModuleAddress());
+			_worker_frame_ptr = slave_ptr->nbusSlaveCmd_getData();
+			_raw_data_frame.AddArray(&DATA0_RX_ADDRESS(_worker_frame_ptr->GetFrame() + 1), _worker_frame_ptr->GetLength() - (RX_META_SIZE + 1));
+		}
 	}
 
+	_raw_data_frame.AddInt8(BRIDGE_TERMINATOR);
+	_raw_data_frame.AddInt8(BRIDGE_TERMINATOR);
 	_raw_data_frame.Commit();
 
 	return &_raw_data_frame;
 }
 
-DataFrame * NbusBridge::getBridgeInfo()
+DataFrame * NbusBridge::bridge_setErrResponse(Nbus_EC_e ec)
 {
-	_raw_data_frame.Init();
-	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_VERSION, 3);
-	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_FAMILY, 3);
-	_raw_data_frame.AddArray((uint8_t *)BRIDGE_INFO_HW_VERSION, 3);
-	_raw_data_frame.Commit();
+	_master_frame.Init();
+	_master_frame.AddUint8(_pdu.ma);
+	_master_frame.AddUint8(_pdu.sa);
+	_master_frame.AddUint8(SET_ERR_RESPONSE(_pdu.fc));
+	_master_frame.AddUint8(ec);
+	_master_frame.Commit();
 
-	return &_raw_data_frame;
+	return &_master_frame;
 }
 
-
-
 /**
  * Implementácia rozhrania nBus.
  */
 void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size)
 {
-    uint8_t crcC = crc8x_fast(rxFrame, size - 1);
+    uint8_t crcC = _crc8x_fast(rxFrame, size - 1);
 
     if (crcC != rxFrame[size - 1])
     {
@@ -395,9 +350,9 @@ void NbusBridge::processRequest(uint8_t *rxFrame, uint8_t size)
 void NbusBridge::processRunningState()
 {
 
-    if (scan_request == 1)
+    if (_scan_request == 1)
     {
-        scan_request = 0;
+        _scan_request = 0;
         this->scan();
     }
 
@@ -414,35 +369,13 @@ void NbusBridge::processRunningState()
     }
 
     HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
-    NbusSlave *slave = NULL;
-    uint8_t *slaveFrameResponse;
-    _raw_data_frame.Init();
-    _raw_data_frame.AddHeader(TYPE_HEADER_2B);
-    _raw_data_frame.AddInt32(HAL_GetTick());
 
-    for (uint32_t i = 0; i < _num_slaves; i++)
-    {
-        slave = getSlave(_slave_adress[i]);
-        if (slave != NULL && slave->isActive())
-        {
-            for (uint32_t k = 1; k <= slave->nbus_get_sensor_count(false); k++)
-            {
-                _raw_data_frame.AddInt8(slave->getModuleAddress());
-                _worker_frame_ptr = slave->nbus_sensor_getData(k);
-                slaveFrameResponse = _worker_frame_ptr->GetFrame();
-                _raw_data_frame.AddInt8(slave->getSensorAddress());
-                _raw_data_frame.AddArray(&slaveFrameResponse[3], _worker_frame_ptr->GetLength() - 3);
-            }
-        }
-    }
+    _worker_frame_ptr = bridge_getData();
 
-    _raw_data_frame.AddInt8(0xFF);
-    _raw_data_frame.AddInt8(0xFF);
-    _raw_data_frame.Commit();
     // TODO problem: v stavi RUNNING pride STOP prikaz, ale ten sa nespracuje, pretoze bezi obsluha tejto funkcie.
     if (_run_state == STATE_RUNNING)
     {
-        _communicator->sendToMaster(&_raw_data_frame);
+        _communicator->sendToMaster(_worker_frame_ptr);
     }
 
     /// TODO toto sa MI NEPACI, TREBA VYRIESIT INAK!!!!!!

Core/Src/NbusCommunicator.cpp

@@ -61,14 +61,28 @@ void NbusCommunicator::_receive()
     _packet_rx.Commit();
 }
 
-DataFrame *NbusCommunicator::sendAndReceive(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len)
+DataFrame *NbusCommunicator::sendAndReceive(Nbus_PDU_t *pdu, uint8_t *data, uint8_t data_len)
 {
     this->send(pdu, data, data_len);
     this->_receive();
     return &_packet_rx;
 }
 
-void NbusCommunicator::send(Nbus_pdu *pdu, uint8_t *data, uint8_t data_len)
+DataFrame *NbusCommunicator::sendAndReceiveSlave(DataFrame *slave_frame)
+{
+    this->sendToSlave(slave_frame);
+    this->_receive();
+    return &_packet_rx;
+}
+
+void NbusCommunicator::sendToSlave(DataFrame *slave_frame)
+{
+    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_SET);
+    HAL_UART_Transmit(_uart_nbus, slave_frame->GetFrame(), slave_frame->GetLength(), 10);
+    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, GPIO_PIN_RESET);
+}
+
+void NbusCommunicator::send(Nbus_PDU_t *pdu, uint8_t *data, uint8_t data_len)
 {
     _packet_tx.Init();
     _packet_tx.AddInt8(pdu->ma); // Module address

Core/Src/NbusSlave.cpp

@@ -1,38 +1,21 @@
 /*
  * @file AppBridge.cpp
- * @brief Implemetnácia mostup na modul nBus Slave.
- * @date Mar 2, 2025
- * @author Juraj Dudak
+ * @brief Implementation of nBus Slave.
+ * @date Nov 26, 2025
+ * @author Juraj Dudak, Matus Necas
  */
 
 #include <NbusSlave.h>
 
-NbusSlave::NbusSlave()
-{
-    _communicator = NULL;
-    _pdu.ma = 0;
-    _pdu.sa = 0;
-}
-
-NbusSlave::NbusSlave(uint8_t address, NbusCommunicator *comm)
-{
-    _communicator = comm;
-    _pdu.ma = address;
-}
 
-NbusSlave::~NbusSlave()
+void NbusSlave::setCommunicator(NbusCommunicator *nbus_comm)
 {
-    // empty
+    _communicator = nbus_comm;
 }
 
-void NbusSlave::setCommunicator(NbusCommunicator *comm)
+void NbusSlave::setAddress(uint8_t addr)
 {
-    _communicator = comm;
-}
-
-void NbusSlave::setAddress(uint8_t address)
-{
-    _pdu.ma = address;
+    _pdu.ma = addr;
 }
 
 uint8_t NbusSlave::getModuleAddress()
@@ -40,94 +23,32 @@ uint8_t NbusSlave::getModuleAddress()
     return _pdu.ma;
 }
 
-uint8_t NbusSlave::getSensorAddress()
+bool NbusSlave::isActive()
 {
-    return _pdu.sa;
+    return _communicator != nullptr && _pdu.ma != 0;
 }
 
-bool NbusSlave::isActive()
+DataFrame *NbusSlave::nbusSlaveCmd_processRequest(DataFrame *slave_frame)
 {
-    //	return _communicator != NULL;
-    return _communicator != NULL && _pdu.ma != 0;
+	return _communicator->sendAndReceiveSlave(slave_frame);
 }
 
-DataFrame *NbusSlave::nbus_echo(uint8_t *echo_data, uint8_t size)
+DataFrame *NbusSlave::nbusSlaveCmd_getData()
 {
-    _pdu.sa = SLAVE_ADDRESS_MODULE;
-    _pdu.fc = FC_ECHO;
-    for (uint32_t i = 0; i < size; i++)
-    {
-        _sensor_cache[i] = echo_data[i];
-    }
-
-    _sensor_count = 0;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, size);
+	_pdu.sa = SLAVE_ADDRESS_MODULE;
+	_pdu.fc = FC_DATA;
+	return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
 }
 
-uint8_t NbusSlave::nbus_get_sensor_count(bool check_hw)
+uint8_t NbusSlave::nbusSlaveCmd_getSensorCnt(bool check_hw)
 {
     if (_sensor_count == 0 || check_hw == true)
     {
-        nbus_sensor_count();
+    	_pdu.sa = SLAVE_ADDRESS_MODULE;
+		_pdu.fc = FC_SENSOR_CNT;
+		DataFrame *df = _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
+		_sensor_count = df->GetFrame()[3];
     }
-    return _sensor_count;
-}
-
-DataFrame *NbusSlave::nbus_sensor_count()
-{
-    _pdu.sa = SLAVE_ADDRESS_MODULE;
-    _pdu.fc = FC_SENSOR_CNT;
-    DataFrame *df = _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-    _sensor_count = df->GetFrame()[3];
-    return df;
-}
-
-DataFrame *NbusSlave::nbus_sensor_type(uint8_t sensor_index)
-{
-    _pdu.sa = sensor_index;
-    _pdu.fc = FC_SENSOR_TYPE;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-}
-
-DataFrame *NbusSlave::nbus_module_info()
-{
-    _pdu.sa = SLAVE_ADDRESS_MODULE;
-    _pdu.fc = FC_INFO;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-}
 
-DataFrame *NbusSlave::nbus_sensor_format(uint8_t sensor_index)
-{
-    _pdu.sa = sensor_index;
-    _pdu.fc = FC_SENSOR_FORMAT;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-}
-
-DataFrame *NbusSlave::nbus_sensor_getData(uint8_t sensor_address)
-{
-    _pdu.sa = sensor_address;
-    _pdu.fc = FC_DATA;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-}
-
-DataFrame *NbusSlave::nbus_sensor_parameter(uint8_t sensor_address, uint8_t parameter)
-{
-    _pdu.sa = sensor_address;
-    _pdu.fc = FC_PARAM;
-    _sensor_cache[0] = parameter;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 1);
-}
-
-DataFrame *NbusSlave::nbus_sensor_parameters(uint8_t sensor_address)
-{
-    _pdu.sa = sensor_address;
-    _pdu.fc = FC_PARAM;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
-}
-
-DataFrame *NbusSlave::nbus_module_find(void)
-{
-    _pdu.sa = SLAVE_ADDRESS_MODULE;
-    _pdu.fc = FC_FIND;
-    return _communicator->sendAndReceive(&_pdu, _sensor_cache, 0);
+    return _sensor_count;
 }