+ fixing bugs

include/app_bridge.h

@@ -12,17 +12,17 @@
 
 typedef enum
 {
-    // OUT subs
+    // read-only sensors
     TYPE_UNKNOWN = 0xFF,
     TYPE_ACCELEROMETER = 0,
     TYPE_GYROSCOPE,
     TYPE_MAGNETOMETER,
     TYPE_THERMOMETER,
-    TYPE_HYGRMOETER,
+    TYPE_HYGROMETER,
     TYPE_PRESSURE_GAUGE,
     TYPE_HEART_RATE_MONITOR,
     TYPE_LENGTH_GAUGE,
-    // IN-OUT subs
+    // read-write sensors
     TYPE_LED_CONTROLLER,
     TYPE_MOTOR_CONTROLLER
 } nBus_sensorType_t;
@@ -81,6 +81,12 @@ typedef struct __attribute__((packed, aligned(1)))
     uint8_t samples : 4;
 } nBus_sensorFormat_t;
 
+typedef struct
+{
+    uint8_t read_only_count;
+    uint8_t read_write_count;
+} nBus_sensorCount_t;
+
 #define PARAM_VALUE_NONE 0x7FFFFFFF
 
 typedef struct
@@ -88,7 +94,7 @@ typedef struct
     void (*init)(void *hw_interface, void *hw_config);
     void (*reset)();
     nBus_sensorType_t (*getType)(uint8_t sensor_index);
-    uint8_t (*getSensorCount)();
+    nBus_sensorCount_t (*getSensorCount)();
 
     uint8_t (*getData)(uint8_t sensor_index, uint8_t *data);
     nBus_statusType_t (*setData)(uint8_t *data, uint8_t count, uint8_t *response);

include/app_dummy.h

@@ -22,7 +22,7 @@ extern "C"
     void dummy_init(void *hw_interface, void *hw_config);
     void dummy_reset();
     nBus_sensorType_t dummy_getType(uint8_t sensor_index);
-    uint8_t dummy_getSensorCount();
+    nBus_sensorCount_t dummy_getSensorCount();
 
     uint8_t dummy_getData(uint8_t sensor_index, uint8_t *data);
     nBus_statusType_t dummy_setData(uint8_t *data, uint8_t count, uint8_t *response);

include/nbus_cmd.h

@@ -32,10 +32,6 @@
 #define CMD_INFO 0x0E
 #define CMD_FORMAT 0x0F
 
-// Command  parameters
-#define INFO_GENERAL 0xE1
-#define INFO_FORMAT 0xE2
-
 #define PARAM_SENSOR_SAMPLERATE 0x41
 #define PARAM_SENSOR_LPF 0x42
 #define PARAM_SENSOR_FULL_SCALE 0x43
@@ -51,6 +47,7 @@
 #define DEVICE_NOT_READY (0x07)
 #define PARAM_NOT_IMPLEMENTED (0x10)
 #define ILLEGAL_FUNCTION_PARAM (0x11)
+#define DEVICE_IS_READ_ONLY (0x12)
 
 /**
  * Chyba pri vykonaní príkazu v subslave, napr. ak senzor nie je pripojený.

include/nbus_types.h

@@ -18,6 +18,43 @@
  */
 #define META_SIZE 5
 
+#define RX_META 4
+
+/**
+ * @brief Index Module Address v RX pakete.
+ */
+#define RX_MA 0
+
+/**
+ * @brief Index Sensor Address v RX pakete.
+ */
+#define RX_SA 1
+
+/**
+ * @brief Index Function Code v RX pakete.
+ */
+#define RX_FC 2
+
+/**
+ * @brief Index Data v RX pakete.
+ */
+#define RX_DT 3
+
+/**
+ * @brief Index Data v TX pakete.
+ */
+#define TX_DT 4
+
+/**
+ * @brief Sensor Read-Only Address offset.
+ */
+#define SENSOR_RO_ADDR 1
+
+/**
+ * @brief Sensor Read-Write Address offset.
+ */
+#define SENSOR_RW_ADDR 129
+
 /**
  * @brief Maximálna veľkosť dátovej časti v pakete.
  */

src/app_dummy.c

@@ -6,8 +6,8 @@ nBusAppInterface_t dummy_driver = {
     dummy_hasParam, dummy_getParam,  dummy_setParam,        dummy_start,          dummy_stop,        dummy_read,
     dummy_store,    dummy_calibrate, dummy_getSensorFormat, dummy_find,           dummy_device_ready};
 
-//////////////////////////////////////////////////////////////      Dummy test data structure
-////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////// Dummy test data structure //////////////////////////////////////////////
+
 uint16_t dummy_data_acc[3] = {0x31F5, 0xCCBD, 0xAABB};              // dec: 12789, -13123, -21829
 uint32_t dummy_data_gyro[3] = {0x1234ABCD, 0xFEDCBA98, 0x89ABCD13}; // dec: 305441741, -19088744, -1985229549
 uint8_t dummy_data_mag[2] = {0xAB, 0x12};                           // dec: 171, 18
@@ -35,7 +35,9 @@ uint8_t *dummy_data_actuators[DUMMY_ACTUATOR_COUNT] = {(uint8_t *)&dummy_data_le
 
 uint8_t dummy_data_actuator_lens[DUMMY_ACTUATOR_COUNT] = {sizeof(dummy_data_led), sizeof(dummy_data_motor)};
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+uint32_t dummy_param = 0xABCD4567;
+
+////////////////////////////////////////////// Dummy test data structure //////////////////////////////////////////////
 
 uint8_t _dummy_memcpy(uint8_t sensor_index, uint8_t *dst, uint8_t *src, uint8_t count)
 {
@@ -86,9 +88,9 @@ nBus_sensorType_t dummy_getType(uint8_t sensor_index)
     return TYPE_UNKNOWN;
 }
 
-uint8_t dummy_getSensorCount()
+nBus_sensorCount_t dummy_getSensorCount()
 {
-    return 7;
+    return (nBus_sensorCount_t){DUMMY_SENSOR_COUNT, DUMMY_ACTUATOR_COUNT};
 }
 
 uint8_t dummy_getData(uint8_t sensor_index, uint8_t *data)
@@ -179,18 +181,24 @@ nBus_statusType_t dummy_setData(uint8_t *data, uint8_t count, uint8_t *response)
 
 int32_t dummy_getParam(uint8_t sensor_index, nBus_param_t param)
 {
-    return 0xABCD4567;
+    return dummy_param;
 }
 
 uint8_t dummy_hasParam(uint8_t sensor_index, nBus_param_t param)
 {
-    if (sensor_index < dummy_getSensorCount())
-        return 1;
-    return 0;
+    if (param == PARAM_GAIN)
+        return 0;
+
+    return 1;
 }
 
 nBus_statusType_t dummy_setParam(uint8_t sensor_index, nBus_param_t param, int32_t value)
 {
+    if (param == PARAM_GAIN)
+        return STATUS_NOT_SUPPORTED;
+
+    dummy_param = value;
+
     return STATUS_SUCCESS;
 }
 

src/nbus_app.c

@@ -249,7 +249,8 @@ void nbus_init_memory_driver(nBus_MemoryDriver *memDriver)
     nBus.memoryInterface->readHeaderData();
 
     uint32_t paramValue;
-    for (uint32_t index = 1; index <= nBus.interface->getSensorCount(); index++)
+    for (uint32_t index = 1; index <= nBus.interface->getSensorCount().read_only_count;
+         index++) // warning only for read only sensors!!!
     {
         for (int paramIndex = 0; paramIndex < _NBUS_PARAM_COUNT; paramIndex++)
         {

src/nbus_slave_module_unicast.c

@@ -5,61 +5,68 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
 {
     switch (nbus->function_code.function)
     {
-    case CMD_FIND: {
-        nbus->tx_buffer[4] = nbus->interface->find(nbus->rx_buffer[3]);
-        nbus->tx_length += 1;
-    }
-    break;
-
     case CMD_ECHO: {
-        for (uint8_t i = 3; i < nbus->rx_length - 1; i++)
+        for (uint8_t i = RX_DT; i < nbus->rx_length - 1; i++)
         {
             nbus->tx_buffer[i + 1] = nbus->rx_buffer[i];
         }
-        nbus->tx_length += (nbus->rx_length - 4);
+        nbus->tx_length += (nbus->rx_length - RX_META);
     }
     break;
 
     case CMD_PARAM: {
-        if (nbus->rx_length == META_SIZE) // get concrete param
+
+        switch (nbus->rx_length)
+        {
+        case RX_META: // get all params
+        {
+            for (uint8_t i = 0, j = 0; i < _NBUS_PARAM_COUNT; i++)
+            {
+                if (nbus->interface->hasParam(0, i))
+                {
+                    int32_t param_value = nbus->interface->getParam(0, i);
+                    nbus->tx_buffer[4 + 5 * j] = i;                             // param id
+                    nbus->tx_buffer[5 + 5 * j] = (uint8_t)(param_value & 0xFF); // param value 4B
+                    nbus->tx_buffer[6 + 5 * j] = (uint8_t)((param_value >> 8) & 0xFF);
+                    nbus->tx_buffer[7 + 5 * j] = (uint8_t)((param_value >> 16) & 0xFF);
+                    nbus->tx_buffer[8 + 5 * j] = (uint8_t)((param_value >> 24) & 0xFF);
+                    nbus->tx_length += 5;
+                    j++;
+                }
+            }
+        }
+        break;
+
+        case RX_META + 1: // get specified parameter: 4 meta + 1 param id
         {
-            if (nbus->interface->hasParam(0, (nBus_param_t)nbus->rx_buffer[3]) == 0) // handle non-existing param
+            if (nbus->interface->hasParam(0, (nBus_param_t)nbus->rx_buffer[RX_DT]) == 0) // handle non-existing param
             {
                 setErrorResponse(nbus, PARAM_NOT_IMPLEMENTED);
                 break;
             }
 
-            nbus->tx_buffer[4] = nbus->rx_buffer[3];                                              // param id
-            int32_t param_value = nbus->interface->getParam(0, (nBus_param_t)nbus->rx_buffer[3]); // param value 4B
+            nbus->tx_buffer[4] = nbus->rx_buffer[RX_DT];                                              // param id
+            int32_t param_value = nbus->interface->getParam(0, (nBus_param_t)nbus->rx_buffer[RX_DT]); // param value 4B
             nbus->tx_buffer[5] = (uint8_t)(param_value & 0xFF);
             nbus->tx_buffer[6] = (uint8_t)((param_value >> 8) & 0xFF);
             nbus->tx_buffer[7] = (uint8_t)((param_value >> 16) & 0xFF);
             nbus->tx_buffer[8] = (uint8_t)((param_value >> 24) & 0xFF);
             nbus->tx_length += 5;
         }
-        else // get all params
-        {
-            for (uint8_t i = 0; i < _NBUS_PARAM_COUNT; i++)
-            {
-                if (nbus->interface->hasParam(0, i))
-                {
-                    int32_t param_value = nbus->interface->getParam(0, i);
-                    nbus->tx_buffer[4 + 5 * i] = i;                             // param id
-                    nbus->tx_buffer[5 + 5 * i] = (uint8_t)(param_value & 0xFF); // param value 4B
-                    nbus->tx_buffer[6 + 5 * i] = (uint8_t)((param_value >> 8) & 0xFF);
-                    nbus->tx_buffer[7 + 5 * i] = (uint8_t)((param_value >> 16) & 0xFF);
-                    nbus->tx_buffer[8 + 5 * i] = (uint8_t)((param_value >> 24) & 0xFF);
+        break;
 
-                    nbus->tx_length += 5;
-                }
-            }
+        default:
+            setErrorResponse(nbus, ILLEGAL_FUNCTION_PARAM);
+            break;
         }
     }
     break;
 
     case CMD_SENSOR_CNT: {
-        nbus->tx_buffer[4] = nbus->interface->getSensorCount();
-        nbus->tx_length += 1;
+        nBus_sensorCount_t sensor_count = nbus->interface->getSensorCount();
+        nbus->tx_buffer[4] = sensor_count.read_only_count;
+        nbus->tx_buffer[5] = sensor_count.read_write_count;
+        nbus->tx_length += 2;
     }
     break;
 
@@ -67,7 +74,7 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
         if (nbus->interface->device_ready())
         {
             // response: sensor1_index:sensor1_data | sensor2_index:sensor2_data | ...
-            uint8_t cnt = nbus->interface->getData(0, &nbus->tx_buffer[4]);
+            uint8_t cnt = nbus->interface->getData(0, &nbus->tx_buffer[TX_DT]);
             if (cnt == 0)
             {
                 setErrorResponse(nbus, DEVICE_BUSY);
@@ -82,11 +89,25 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_SENSOR_TYPE: {
+
+        nBus_sensorCount_t sensor_count = nbus->interface->getSensorCount();
+
         // response: sensor1_index:sensor1_type | sensor2_index:sensor2_type | ...
-        for (uint8_t i = 0; i < nbus->interface->getSensorCount(); i++)
+
+        // add read_only sensors
+        uint8_t i = 0;
+        for (; i < sensor_count.read_only_count; i++)
+        {
+            nbus->tx_buffer[4 + 2 * i] = i + SENSOR_RO_ADDR;
+            nbus->tx_buffer[5 + 2 * i] = nbus->interface->getType(i + SENSOR_RO_ADDR);
+            nbus->tx_length += 2;
+        }
+
+        // add read_write sensors
+        for (uint8_t j = 0; j < sensor_count.read_write_count; j++, i++)
         {
-            nbus->tx_buffer[4 + 2 * i] = i;
-            nbus->tx_buffer[5 + 2 * i] = nbus->interface->getType(i);
+            nbus->tx_buffer[4 + 2 * i] = j + SENSOR_RW_ADDR;
+            nbus->tx_buffer[5 + 2 * i] = nbus->interface->getType(j + SENSOR_RW_ADDR);
             nbus->tx_length += 2;
         }
     }
@@ -137,19 +158,36 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_FORMAT: {
-        uint8_t sensor_cnt = nbus->interface->getSensorCount();
+        nBus_sensorCount_t sensor_count = nbus->interface->getSensorCount();
+        nBus_sensorFormat_t format;
+        uint8_t *format_ptr;
 
-        for (int8_t i = 0; i < sensor_cnt; ++i)
+        // add read_only sensors
+        uint8_t i = 0;
+        for (; i < sensor_count.read_only_count; ++i)
         {
-            nBus_sensorFormat_t format = nbus->interface->getSensorFormat(i + 1);
-            uint8_t *format_ptr = (uint8_t *)&format;
-            nbus->tx_buffer[4 * i + 4] = i + 1;
+            format = nbus->interface->getSensorFormat(i + SENSOR_RO_ADDR);
+            format_ptr = (uint8_t *)&format;
+            nbus->tx_buffer[4 * i + 4] = i + SENSOR_RO_ADDR;
             nbus->tx_buffer[4 * i + 5] = format_ptr[0];
             nbus->tx_buffer[4 * i + 6] = format_ptr[1];
             nbus->tx_buffer[4 * i + 7] = format_ptr[2];
         }
 
-        nbus->tx_length += 4 * sensor_cnt;
+        nbus->tx_length += 4 * sensor_count.read_only_count;
+
+        // add read_write sensors
+        for (uint8_t j = 0; j < sensor_count.read_write_count; ++j, ++i)
+        {
+            format = nbus->interface->getSensorFormat(j + SENSOR_RW_ADDR);
+            format_ptr = (uint8_t *)&format;
+            nbus->tx_buffer[4 * i + 4] = j + SENSOR_RW_ADDR;
+            nbus->tx_buffer[4 * i + 5] = format_ptr[0];
+            nbus->tx_buffer[4 * i + 6] = format_ptr[1];
+            nbus->tx_buffer[4 * i + 7] = format_ptr[2];
+        }
+
+        nbus->tx_length += 4 * sensor_count.read_write_count;
     }
     break;
 
@@ -163,10 +201,15 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
 {
     switch (nbus->function_code.function)
     {
-    case CMD_START: {
-        nbus->measure_active = MEASURE_RUNNING;
-        nbus->interface->start();
-        nbus->hw_platform->led_on();
+    case CMD_FIND: {
+        if (nbus->rx_buffer[RX_DT] > 1) // if wrong parameter {0, 1}
+        {
+            setErrorResponse(nbus, ILLEGAL_FUNCTION_PARAM);
+            break;
+        }
+
+        nbus->tx_buffer[TX_DT] = nbus->interface->find(nbus->rx_buffer[RX_DT]);
+        nbus->tx_length += 1;
     }
     break;
 
@@ -177,9 +220,16 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
     }
     break;
 
+    case CMD_START: {
+        nbus->measure_active = MEASURE_RUNNING;
+        nbus->interface->start();
+        nbus->hw_platform->led_on();
+    }
+    break;
+
     case CMD_PARAM: {
 
-        uint8_t rx_payload = nbus->rx_length - META_SIZE;
+        uint8_t rx_payload = nbus->rx_length - RX_META;
 
         // empty or wrong number of parameters
         if (rx_payload == 0 || rx_payload % 5 != 0)
@@ -195,7 +245,7 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
             for (uint8_t i = 0; i < rx_payload; i++)
             {
                 param_id = nbus->rx_buffer[3 + 5 * i];
-                param_value = *(int32_t *)nbus->rx_buffer[4 + 5 * i];
+                param_value = *(int32_t *)&nbus->rx_buffer[4 + 5 * i];
 
                 nbus->tx_buffer[4 + 2 * i] = param_id;
                 nbus->tx_buffer[5 + 2 * i] = nbus->interface->setParam(0, param_id, param_value);
@@ -219,7 +269,7 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
 
     case CMD_CALIBRATE: {
         nbus->hw_platform->led_on();
-        nbus->tx_buffer[4] = nbus->interface->calibrate(0);
+        nbus->tx_buffer[TX_DT] = nbus->interface->calibrate(0);
         nbus->tx_length += 1;
         nbus->hw_platform->led_off();
     }
@@ -228,7 +278,7 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
     case CMD_DATA: {
 
         nbus->tx_length +=
-            nbus->interface->setData(&nbus->rx_buffer[3], nbus->rx_length - META_SIZE, &nbus->tx_buffer[4]);
+            nbus->interface->setData(&nbus->rx_buffer[RX_DT], nbus->rx_length - RX_META, &nbus->tx_buffer[TX_DT]);
     }
     break;
 

src/nbus_slave_sensor_unicast.c

@@ -4,8 +4,7 @@
 
 void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
 {
-    nBus_sensorType_t sensor_type =
-        nbus->interface->getType(nbus->rx_buffer[1]); // nbus->rx_buffer[1] is whole address with type
+    nBus_sensorType_t sensor_type = nbus->interface->getType(nbus->rx_buffer[RX_SA]);
 
     if (sensor_type == TYPE_UNKNOWN) // handle bad sensor address
     {
@@ -16,40 +15,52 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
     switch (nbus->function_code.function)
     {
     case CMD_PARAM: {
-        if (nbus->rx_length == META_SIZE) // get concrete param
+
+        switch (nbus->rx_length)
+        {
+        case RX_META: // get all params
+        {
+            for (uint8_t i = 0, j = 0; i < _NBUS_PARAM_COUNT; i++)
+            {
+                if (nbus->interface->hasParam(nbus->rx_buffer[RX_SA], i))
+                {
+                    int32_t param_value = nbus->interface->getParam(nbus->rx_buffer[RX_SA], i);
+                    nbus->tx_buffer[4 + 5 * j] = i;                             // param id
+                    nbus->tx_buffer[5 + 5 * j] = (uint8_t)(param_value & 0xFF); // param value 4B
+                    nbus->tx_buffer[6 + 5 * j] = (uint8_t)((param_value >> 8) & 0xFF);
+                    nbus->tx_buffer[7 + 5 * j] = (uint8_t)((param_value >> 16) & 0xFF);
+                    nbus->tx_buffer[8 + 5 * j] = (uint8_t)((param_value >> 24) & 0xFF);
+
+                    nbus->tx_length += 5;
+                    j++;
+                }
+            }
+        }
+        break;
+
+        case RX_META + 1: // get specified parameter: 4 meta + 1 param id
         {
-            if (nbus->interface->hasParam(nbus->rx_buffer[1], (nBus_param_t)nbus->rx_buffer[3]) ==
+            if (nbus->interface->hasParam(nbus->rx_buffer[RX_SA], (nBus_param_t)nbus->rx_buffer[RX_DT]) ==
                 0) // handle non-existing param
             {
                 setErrorResponse(nbus, PARAM_NOT_IMPLEMENTED);
                 break;
             }
 
-            nbus->tx_buffer[4] = nbus->rx_buffer[3]; // param id
-            int32_t param_value =
-                nbus->interface->getParam(nbus->rx_buffer[1], (nBus_param_t)nbus->rx_buffer[3]); // param value 4B
+            nbus->tx_buffer[4] = nbus->rx_buffer[RX_DT]; // param id
+            int32_t param_value = nbus->interface->getParam(nbus->rx_buffer[RX_SA],
+                                                            (nBus_param_t)nbus->rx_buffer[RX_DT]); // param value 4B
             nbus->tx_buffer[5] = (uint8_t)(param_value & 0xFF);
             nbus->tx_buffer[6] = (uint8_t)((param_value >> 8) & 0xFF);
             nbus->tx_buffer[7] = (uint8_t)((param_value >> 16) & 0xFF);
             nbus->tx_buffer[8] = (uint8_t)((param_value >> 24) & 0xFF);
             nbus->tx_length += 5;
         }
-        else // get all params
-        {
-            for (uint8_t i = 0; i < _NBUS_PARAM_COUNT; i++)
-            {
-                if (nbus->interface->hasParam(nbus->rx_buffer[1], i))
-                {
-                    int32_t param_value = nbus->interface->getParam(nbus->rx_buffer[1], i);
-                    nbus->tx_buffer[4 + 5 * i] = i;                             // param id
-                    nbus->tx_buffer[5 + 5 * i] = (uint8_t)(param_value & 0xFF); // param value 4B
-                    nbus->tx_buffer[6 + 5 * i] = (uint8_t)((param_value >> 8) & 0xFF);
-                    nbus->tx_buffer[7 + 5 * i] = (uint8_t)((param_value >> 16) & 0xFF);
-                    nbus->tx_buffer[8 + 5 * i] = (uint8_t)((param_value >> 24) & 0xFF);
+        break;
 
-                    nbus->tx_length += 5;
-                }
-            }
+        default:
+            setErrorResponse(nbus, ILLEGAL_FUNCTION_PARAM);
+            break;
         }
     }
     break;
@@ -57,7 +68,7 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
     case CMD_DATA: {
         if (nbus->interface->device_ready())
         {
-            uint8_t cnt = nbus->interface->getData(nbus->rx_buffer[1], &nbus->tx_buffer[4]);
+            uint8_t cnt = nbus->interface->getData(nbus->rx_buffer[RX_SA], &nbus->tx_buffer[TX_DT]);
             if (cnt == 0)
             {
                 setErrorResponse(nbus, DEVICE_BUSY);
@@ -73,15 +84,15 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_SENSOR_TYPE: {
-        nbus->tx_buffer[4] = sensor_type;
+        nbus->tx_buffer[TX_DT] = sensor_type;
         nbus->tx_length += 1;
         break;
     }
 
     case CMD_FORMAT: {
-        nBus_sensorFormat_t format = nbus->interface->getSensorFormat(nbus->rx_buffer[1]);
+        nBus_sensorFormat_t format = nbus->interface->getSensorFormat(nbus->rx_buffer[RX_SA]);
         uint8_t *format_ptr = (uint8_t *)&format;
-        nbus->tx_buffer[4] = nbus->rx_buffer[1]; // sensor address and type
+        nbus->tx_buffer[4] = nbus->rx_buffer[RX_SA]; // sensor address
         nbus->tx_buffer[5] = format_ptr[0];
         nbus->tx_buffer[6] = format_ptr[1];
         nbus->tx_buffer[7] = format_ptr[2];
@@ -98,7 +109,7 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
 void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
 {
     nBus_sensorType_t sensor_type =
-        nbus->interface->getType(nbus->rx_buffer[1]); // nbus->rx_buffer[1] is whole address with type
+        nbus->interface->getType(nbus->rx_buffer[RX_SA]); // nbus->rx_buffer[1] is whole address with type
 
     if (sensor_type == TYPE_UNKNOWN) // handle bad sensor address
     {
@@ -110,7 +121,7 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
     {
     case CMD_PARAM: {
 
-        uint8_t rx_payload = nbus->rx_length - META_SIZE;
+        uint8_t rx_payload = nbus->rx_length - RX_META;
 
         // empty or wrong number of parameters
         if (rx_payload == 0 || rx_payload % 5 != 0)
@@ -126,10 +137,10 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
             for (uint8_t i = 0; i < rx_payload; i++)
             {
                 param_id = nbus->rx_buffer[3 + 5 * i];
-                param_value = *(int32_t *)nbus->rx_buffer[4 + 5 * i];
+                param_value = *(int32_t *)&nbus->rx_buffer[4 + 5 * i];
 
                 nbus->tx_buffer[4 + 2 * i] = param_id;
-                nbus->tx_buffer[5 + 2 * i] = nbus->interface->setParam(nbus->rx_buffer[1], param_id, param_value);
+                nbus->tx_buffer[5 + 2 * i] = nbus->interface->setParam(nbus->rx_buffer[RX_SA], param_id, param_value);
                 nbus->tx_length += 2;
             }
         }
@@ -138,7 +149,7 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
 
     case CMD_CALIBRATE: {
         nbus->hw_platform->led_on();
-        nbus->tx_buffer[4] = nbus->interface->calibrate(nbus->rx_buffer[1]);
+        nbus->tx_buffer[TX_DT] = nbus->interface->calibrate(nbus->rx_buffer[RX_SA]);
         nbus->tx_length += 1;
         nbus->hw_platform->led_off();
         break;
@@ -147,21 +158,21 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
     case CMD_DATA: {
         if (nbus->sensorInfo.type == 0) // if device is output only (sensor)
         {
-            setErrorResponse(nbus, ERR_OUTPUT_ONLY);
+            setErrorResponse(nbus, DEVICE_IS_READ_ONLY);
             break;
         }
 
         nbus->tx_length +=
-            nbus->interface->setData(&nbus->rx_buffer[3], nbus->rx_length - META_SIZE, &nbus->tx_buffer[4]);
+            nbus->interface->setData(&nbus->rx_buffer[RX_DT], nbus->rx_length - RX_META, &nbus->tx_buffer[TX_DT]);
     }
     break;
 
     case CMD_STORE: {
         for (uint32_t i = 0; i < _NBUS_PARAM_COUNT; i++)
         {
-            if (nbus->interface->hasParam(nbus->sensorInfo.address, i))
+            if (nbus->interface->hasParam(nbus->rx_buffer[RX_SA], i))
             {
-                sensor_store_param(nbus, nbus->sensorInfo.address, i);
+                sensor_store_param(nbus, nbus->rx_buffer[RX_SA], i);
                 // param_value = nbus->interface->getParam(nbus->sensorInfo.address,
                 // all_params[i]);
                 // nbus->memoryInterface->storeParam(nbus->sensorInfo.address,
@@ -169,7 +180,7 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
             }
         }
 
-        nbus->tx_buffer[4] = 1;
+        nbus->tx_buffer[TX_DT] = 1;
         nbus->tx_length += 1;
     }
     break;