+ first cmd nBus revision

include/app_bridge.h

@@ -12,15 +12,19 @@
 
 typedef enum
 {
+    // OUT subs
     TYPE_UNKNOWN = 0xFF,
     TYPE_ACCELEROMETER = 0,
     TYPE_GYROSCOPE,
     TYPE_MAGNETOMETER,
-    TYPE_TEMPERATURE,
-    TYPE_HUMIDITY,
-    TYPE_PRESSURE,
-    TYPE_HEART_RATE,
-    TYPE_DEVIATION_DISTANCE,
+    TYPE_THERMOMETER,
+    TYPE_HYGRMOETER,
+    TYPE_PRESSURE_GAUGE,
+    TYPE_HEART_RATE_MONITOR,
+    TYPE_LENGTH_GAUGE,
+    // IN-OUT subs
+    TYPE_LED_CONTROLLER,
+    TYPE_MOTOR_CONTROLLER
 } nBus_sensorType_t;
 
 typedef enum
@@ -33,9 +37,17 @@ typedef enum
     PARAM_SAMPLERATE,
     PARAM_RANGE,
     PARAM_RANGE0,
-    PARAM_FILTER
+    PARAM_FILTER,
+    _NBUS_PARAM_COUNT  // number of parameters, must be last!
 } nBus_param_t;
 
+typedef enum 
+{
+    STATUS_NOT_SUPPORTED = 0xFF,
+    STATUS_SUCCESS = 0,
+    STATUS_FAIL = 1
+} nBus_statusType_t;
+
 /**
  * @brief Definuje formát dát senzora.
  * @note Bajtová reprezentácia (Little Endian) bude nasledovná: | unit_multiplier | sign | value_multiplier | samples |
@@ -71,29 +83,29 @@ typedef struct __attribute__((packed, aligned(1)))
 
 #define PARAM_VALUE_NONE 0x7FFFFFFF
 
-nBus_param_t *nbus_interface_allParams();
-uint8_t nbus_interface_allParamsCount();
-
-nBus_sensorType_t *nbus_interface_allTypes();
-uint8_t nbus_interface_allTypesCount();
-
 typedef struct
 {
     void (*init)(void *hw_interface, void *hw_config);
     void (*reset)();
     nBus_sensorType_t (*getType)(uint8_t sensor_index);
-    uint8_t (*getSensorCount)();
+    uint8_t (*getSensorCount)(); 
+
     uint8_t (*getData)(uint8_t sensor_index, uint8_t *data);
-    uint8_t (*setData)(uint8_t *data);
+    nBus_statusType_t (*setData)(uint8_t *data, uint8_t count, uint8_t *response);
+   
     uint8_t (*hasParam)(uint8_t sensor_index, nBus_param_t param_name);
     int32_t (*getParam)(uint8_t sensor_index, nBus_param_t param_name);
-    nBus_param_t (*setParam)(uint8_t sensor_index, nBus_param_t param_name, int32_t param_value);
+    nBus_statusType_t (*setParam)(uint8_t sensor_index, nBus_param_t param_name, int32_t param_value);
+    
     void (*start)(void);
     void (*stop)(void);
     void (*read)(void);
     uint8_t (*store)(void);
-    uint8_t (*calibrate)(uint8_t subslaveIndex, uint8_t calibrationParamsNum, uint8_t *calibrationParams);
+    
+    nBus_statusType_t (*calibrate)(uint8_t sensor_index);
     nBus_sensorFormat_t (*getSensorFormat)(uint8_t sensor_index);
+    nBus_statusType_t (*find)(uint8_t enable);
+    uint8_t (*device_ready)();
 } nBusAppInterface_t;
 
 #endif /* MODULES_NBUS_INC_APP_BRIDGE_H_ */

include/app_dummy.h

@@ -22,19 +22,24 @@ 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();
+    uint8_t dummy_getSensorCount(); 
+
     uint8_t dummy_getData(uint8_t sensor_index, uint8_t *data);
-    uint8_t dummy_setData(uint8_t *data);
-    int32_t dummy_getParam(uint8_t sensor_index, nBus_param_t param);
-    uint8_t dummy_hasParam(uint8_t sensor_index, nBus_param_t param);
-    nBus_param_t dummy_setParam(uint8_t sensor_index, nBus_param_t param, int32_t value);
+    nBus_statusType_t dummy_setData(uint8_t *data, uint8_t count, uint8_t *response);
+   
+    uint8_t dummy_hasParam(uint8_t sensor_index, nBus_param_t param_name);
+    int32_t dummy_getParam(uint8_t sensor_index, nBus_param_t param_name);
+    nBus_statusType_t dummy_setParam(uint8_t sensor_index, nBus_param_t param_name, int32_t param_value);
+    
     void dummy_start(void);
     void dummy_stop(void);
     void dummy_read(void);
     uint8_t dummy_store(void);
-    uint8_t dummy_calibrate(uint8_t subslaveIndex, uint8_t calibrationParamsNum, uint8_t *calibrationParams);
+    
+    nBus_statusType_t dummy_calibrate(uint8_t sensor_index);
     nBus_sensorFormat_t dummy_getSensorFormat(uint8_t sensor_index);
-
+    nBus_statusType_t dummy_find(uint8_t enable);
+    uint8_t dummy_device_ready();
 #ifdef __cplusplus
 }
 #endif

include/nbus_cmd.h

@@ -15,6 +15,7 @@
 #ifndef NBUS_CMD_H
 #define NBUS_CMD_H
 
+#define CMD_FIND 0x00
 #define CMD_ECHO 0x01
 #define CMD_STOP 0x02
 #define CMD_START 0x03
@@ -29,6 +30,7 @@
 #define CMD_SYNC 0x0C
 #define CMD_SENSOR_TYPE 0x0D
 #define CMD_INFO 0x0E
+#define CMD_FORMAT 0x0F
 
 // Command  parameters
 #define INFO_GENERAL 0xE1
@@ -48,6 +50,7 @@
 #define DEVICE_BUSY (0x06)
 #define DEVICE_NOT_READY (0x07)
 #define PARAM_NOT_IMPLEMENTED (0x10)
+#define ILLEGAL_FUNCTION_PARAM (0x11)
 
 /**
  * Chyba pri vykonaní príkazu v subslave, napr. ak senzor nie je pripojený.

src/app_bridge.c

@@ -1,32 +0,0 @@
-/*
- * app_bridge.c
- *
- *  Created on: Nov 2, 2023
- *      Author: juraj
- */
-#include "app_bridge.h"
-
-nBus_param_t allParams[] = {PARAM_TIMEBASE,   PARAM_RESOLUTION, PARAM_GAIN,   PARAM_OFFSET,
-                            PARAM_SAMPLERATE, PARAM_RANGE,      PARAM_RANGE0, PARAM_FILTER};
-nBus_sensorType_t allTypes[] = {TYPE_ACCELEROMETER, TYPE_GYROSCOPE, TYPE_MAGNETOMETER, TYPE_TEMPERATURE,
-                                TYPE_HUMIDITY,      TYPE_PRESSURE,  TYPE_HEART_RATE};
-
-nBus_param_t *nbus_interface_allParams()
-{
-    return allParams;
-}
-
-uint8_t nbus_interface_allParamsCount()
-{
-    return sizeof(allParams) / sizeof(nBus_param_t);
-}
-
-nBus_sensorType_t *nbus_interface_allTypes()
-{
-    return allTypes;
-}
-
-uint8_t nbus_interface_allTypesCount()
-{
-    return sizeof(allTypes) / sizeof(nBus_sensorType_t);
-}

src/app_dummy.c

@@ -1,12 +1,61 @@
 #include "app_dummy.h"
 #include <stdint.h>
 
+
 nBusAppInterface_t dummy_driver = {
     dummy_init,    dummy_reset,    dummy_getType,  dummy_getSensorCount, dummy_getData,
     dummy_setData, 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    ///////////////////////////////////////////////////////////////////// 
+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
+uint64_t dummy_data_hrate[2] = {0x1234ABCD7890ABCD, 0xABCD123498765432}; // dec: 1311862290451049421, -6067173105892699086
+uint16_t dummy_data_pressure[1] = {0x7FAB};                              // dec: 32683
+uint8_t dummy_data_led = 0;
+uint16_t dummy_data_motor[2] = {0x0000, 0x0000};
+
+
+#define DUMMY_SUB_COUNT 7
+#define DUMMY_SENSOR_COUNT 5
+#define DUMMY_ACTUATOR_COUNT 2
+
+
+// dummy sensors
+uint8_t *dummy_data_sensors[DUMMY_SENSOR_COUNT] = {(uint8_t *)dummy_data_acc, (uint8_t *)dummy_data_gyro, (uint8_t *)dummy_data_mag,
+                                                   (uint8_t *)dummy_data_hrate, (uint8_t *)dummy_data_pressure};
+
+uint8_t dummy_data_sensor_lens[DUMMY_SENSOR_COUNT] = {sizeof(dummy_data_acc), sizeof(dummy_data_gyro), sizeof(dummy_data_mag), sizeof(dummy_data_hrate),
+                                                      sizeof(dummy_data_pressure)};
+
+// dummy actuators
+uint8_t *dummy_data_actuators[DUMMY_ACTUATOR_COUNT] = {(uint8_t *)&dummy_data_led, (uint8_t *)dummy_data_motor};
+
+
+uint8_t dummy_data_actuator_lens[DUMMY_ACTUATOR_COUNT] = {sizeof(dummy_data_led), sizeof(dummy_data_motor)};
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
+
+
+uint8_t _dummy_memcpy(uint8_t sensor_index, uint8_t *dst, uint8_t *src, uint8_t count)
+{
+    uint8_t i = 0;
+    
+    dst[i] = sensor_index;
+    
+    for (; i < count; i++)
+        dst[i + 1] = src[i]; 
+    
+    return i + 1;
+ }
+
+
+
 nBusAppInterface_t *getDummyDriver()
 {
     return &dummy_driver;
@@ -14,18 +63,16 @@ nBusAppInterface_t *getDummyDriver()
 
 void dummy_init(void *hw_interface, void *hw_config)
 {
+    // init whole module
 }
 
 void dummy_reset()
 {
+    // reset all devices
 }
 
 nBus_sensorType_t dummy_getType(uint8_t sensor_index)
 {
-
-    if (sensor_index > dummy_getSensorCount())
-        return TYPE_UNKNOWN;
-
     switch (sensor_index)
     {
     case 1:
@@ -35,66 +82,108 @@ nBus_sensorType_t dummy_getType(uint8_t sensor_index)
     case 3:
         return TYPE_MAGNETOMETER;
     case 4:
-        return TYPE_HEART_RATE;
+        return TYPE_HEART_RATE_MONITOR;
     case 5:
-        return TYPE_PRESSURE;
+        return TYPE_PRESSURE_GAUGE;
+    case 129:
+        return TYPE_LED_CONTROLLER;
+    case 130:
+        return TYPE_MOTOR_CONTROLLER;
     }
     return TYPE_UNKNOWN;
 }
 
 uint8_t dummy_getSensorCount()
 {
-    return 5;
+    return 7;
 }
 
-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
-uint64_t dummy_data_hrate[2] = {0x1234ABCD7890ABCD,
-                                0xABCD123498765432}; // dec: 1311862290451049421, -6067173105892699086
-uint16_t dummy_pressure[1] = {0x7FAB};               // dec: 32683
-
-uint8_t *dummy_data_ptrs[5] = {(uint8_t *)dummy_data_acc, (uint8_t *)dummy_data_gyro, (uint8_t *)dummy_data_mag,
-                               (uint8_t *)dummy_data_hrate, (uint8_t *)dummy_pressure};
-uint8_t dummy_data_lens[5] = {6, 12, 2, 16, 2};
 
 uint8_t dummy_getData(uint8_t sensor_index, uint8_t *data)
 {
-    uint16_t current_len = 0;
+    uint8_t buff_index = 0;
 
-    if (sensor_index)
+    switch (sensor_index)
     {
-        data[current_len++] = sensor_index;
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+        return _dummy_memcpy(sensor_index, data, dummy_data_sensors[sensor_index - 1], dummy_data_sensor_lens[sensor_index - 1]);
 
-        uint16_t byte_len = dummy_data_lens[sensor_index - 1];
+    case 129:
+    case 130:
+        return _dummy_memcpy(sensor_index, data, dummy_data_actuators[sensor_index - 129], dummy_data_actuator_lens[sensor_index - 129]);
 
-        for (uint16_t i = 0; i < byte_len; i++)
-        {
-            data[current_len++] = dummy_data_ptrs[sensor_index - 1][i];
-        }
-    }
-    else
+    case 0:
     {
-        uint16_t sensors = dummy_getSensorCount();
+        uint8_t buff_index = 0;
+        
+        for (uint8_t i = 0; i < DUMMY_SENSOR_COUNT; i++)
+            buff_index += _dummy_memcpy(i + 1, data + buff_index, dummy_data_sensors[i], dummy_data_sensor_lens[i]);
+
+        for (uint8_t i = 0; i < DUMMY_ACTUATOR_COUNT; i++)
+            buff_index += _dummy_memcpy(i + 129, data + buff_index, dummy_data_actuators[i], dummy_data_actuator_lens[i]);    
+
+        return buff_index;
+    }
+    break;
+
+    default:
+        return 0;
+    }
+}
 
-        for (uint16_t sensor = 0; sensor < sensors; sensor++)
+nBus_statusType_t dummy_setData(uint8_t *data, uint8_t count, uint8_t *response)
+{
+    uint8_t actuaror_id; 
+    nBus_sensorFormat_t actuator_format;
+    uint8_t actuator_byte_count;
+    uint8_t response_idx = 0;
+    uint8_t data_idx = 0;
+
+
+    while(data_idx < count)
+    {
+        actuaror_id = data[data_idx++]; // fetch actuator id
+        
+        switch (actuaror_id)
         {
-            data[current_len++] = sensor + 1;
-            uint16_t byte_len = dummy_data_lens[sensor];
+        case 129:
+        case 130:
+        {
+            actuator_format = dummy_getSensorFormat(actuaror_id);
+            actuator_byte_count = actuator_format.samples * actuator_format.byte_length;
+
+            // check for overflow
+           // if (data_idx + actuator_byte_count > count)
+            {
+                //response[response_idx++] = actuaror_id;
+                //response[response_idx++] = STATUS_FAIL;
+                //data_idx = count;
+                //break;
+            }
 
-            for (uint16_t i = 0; i < byte_len; i++)
+            for (uint8_t i = 0; i < actuator_byte_count; i++)
             {
-                data[current_len++] = dummy_data_ptrs[sensor][i];
+        
+                dummy_data_actuators[actuaror_id - 129][i] = data[data_idx++];
             }
+
+            response[response_idx++] = actuaror_id;
+            response[response_idx++] = STATUS_SUCCESS;
         }
-    }
+        break;
 
-    return current_len;
-}
+        default:
+            response[response_idx++] = actuaror_id;
+            response[response_idx++] = STATUS_NOT_SUPPORTED;
+        }
 
-uint8_t dummy_setData(uint8_t *data)
-{
-    return 1;
+    }
+    
+    return response_idx;
 }
 
 int32_t dummy_getParam(uint8_t sensor_index, nBus_param_t param)
@@ -109,9 +198,9 @@ uint8_t dummy_hasParam(uint8_t sensor_index, nBus_param_t param)
     return 0;
 }
 
-nBus_param_t dummy_setParam(uint8_t sensor_index, nBus_param_t param, int32_t value)
+nBus_statusType_t dummy_setParam(uint8_t sensor_index, nBus_param_t param, int32_t value)
 {
-    return param;
+    return STATUS_SUCCESS;
 }
 
 void dummy_start(void)
@@ -134,9 +223,9 @@ uint8_t dummy_store(void)
     return 0;
 }
 
-uint8_t dummy_calibrate(uint8_t subslaveIndex, uint8_t calibrationParamsNum, uint8_t *calibrationParams)
+ nBus_statusType_t dummy_calibrate(uint8_t sensor_index)
 {
-    return 0;
+    return STATUS_NOT_SUPPORTED;
 }
 
 nBus_sensorFormat_t dummy_getSensorFormat(uint8_t sensor_index)
@@ -163,5 +252,23 @@ nBus_sensorFormat_t dummy_getSensorFormat(uint8_t sensor_index)
         return (nBus_sensorFormat_t){
             .sign = 1, .unit_multiplier = 4, .value_multiplier = -3, .byte_length = 2, .samples = 1};
         break;
+    case 129:
+        return (nBus_sensorFormat_t){
+            .sign = 0, .unit_multiplier = 0, .value_multiplier = 0, .byte_length = 1, .samples = 1};
+        break;
+    case 130:
+        return (nBus_sensorFormat_t){
+            .sign = 1, .unit_multiplier = 1, .value_multiplier = -3, .byte_length = 2, .samples = 2};
+        break;
     }
 }
+
+nBus_statusType_t dummy_find(uint8_t enable)
+{
+    return STATUS_NOT_SUPPORTED;
+}
+
+uint8_t dummy_device_ready()
+{
+    return 1;
+}

src/nbus_app.c

@@ -248,19 +248,17 @@ void nbus_init_memory_driver(nBus_MemoryDriver *memDriver)
 
     nBus.memoryInterface->readHeaderData();
 
-    uint8_t *params = nbus_interface_allParams();
-    uint8_t paramCnt = nbus_interface_allParamsCount();
     uint32_t paramValue;
     for (uint32_t index = 1; index <= nBus.interface->getSensorCount(); index++)
     {
-        for (int paramIndex = 0; paramIndex < paramCnt; paramIndex++)
+        for (int paramIndex = 0; paramIndex < _NBUS_PARAM_COUNT; paramIndex++)
         {
-            if (nbus_is_param_active(index, params[paramIndex]))
+            if (nbus_is_param_active(index, paramIndex))
             {
-                if (nBus.interface->hasParam(index, params[paramIndex]))
+                if (nBus.interface->hasParam(index, paramIndex))
                 {
-                    paramValue = nbus_memory_read_param(index, params[paramIndex]);
-                    nBus.interface->setParam(index, params[paramIndex], paramValue);
+                    paramValue = nbus_memory_read_param(index, paramIndex);
+                    nBus.interface->setParam(index, paramIndex, paramValue);
                 }
             }
         }

src/nbus_slave_module_unicast.c

@@ -5,6 +5,12 @@ 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++)
         {
@@ -12,11 +18,10 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
         }
         nbus->tx_length += (nbus->rx_length - 4);
     }
-
     break;
 
     case CMD_PARAM: {
-        if (nbus->rx_length >= 5) // get concrete param
+        if (nbus->rx_length == META_SIZE) // get concrete param
         {
             if (nbus->interface->hasParam(0, (nBus_param_t)nbus->rx_buffer[3]) == 0) // handle non-existing param
             {
@@ -25,7 +30,7 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
             }
 
             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]);
+            int32_t param_value = nbus->interface->getParam(0, (nBus_param_t)nbus->rx_buffer[3]); // 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);
@@ -34,16 +39,13 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
         }
         else // get all params
         {
-            nBus_param_t *params = nbus_interface_allParams();
-            for (uint8_t i = 0; i < nbus_interface_allParamsCount(); i++)
+            for (uint8_t i = 0; i < _NBUS_PARAM_COUNT; i++)
             {
-                if (nbus->interface->hasParam(0, params[i]))
+                if (nbus->interface->hasParam(0, i))
                 {
-                    int32_t param_value = nbus->interface->getParam(0, params[i]);
-                    nbus->tx_buffer[4 + 5 * i] = params[i]; // param id
-                    // nbus->tx_buffer[5+2*i] =
-                    // nbus->interface->getParam(0, params[i]);
-                    nbus->tx_buffer[5 + 5 * i] = (uint8_t)(param_value & 0xFF);
+                    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);
@@ -62,7 +64,7 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_DATA: {
-        if (nbus->measure_active == MEASURE_RUNNING)
+        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]);
@@ -91,69 +93,64 @@ void nbus_slave_unicastToModuleGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_INFO: {
-        switch (nbus->rx_buffer[3])
-        {
-        case INFO_GENERAL: {
-            // name
-            nbus->tx_buffer[4] = MODULE_NAME[0];
-            nbus->tx_buffer[5] = MODULE_NAME[1];
-            nbus->tx_buffer[6] = MODULE_NAME[2];
-            nbus->tx_buffer[7] = MODULE_NAME[3];
-            nbus->tx_buffer[8] = MODULE_NAME[4];
-            nbus->tx_buffer[9] = MODULE_NAME[5];
-            nbus->tx_buffer[10] = MODULE_NAME[6];
-            nbus->tx_buffer[11] = MODULE_NAME[7];
-            nbus->tx_length += 8;
-            // type
-            nbus->tx_buffer[12] = MODULE_TYPE[0];
-            nbus->tx_buffer[13] = MODULE_TYPE[1];
-            nbus->tx_buffer[14] = MODULE_TYPE[2];
-            nbus->tx_length += 3;
+        // name
+        nbus->tx_buffer[4] = MODULE_NAME[0];
+        nbus->tx_buffer[5] = MODULE_NAME[1];
+        nbus->tx_buffer[6] = MODULE_NAME[2];
+        nbus->tx_buffer[7] = MODULE_NAME[3];
+        nbus->tx_buffer[8] = MODULE_NAME[4];
+        nbus->tx_buffer[9] = MODULE_NAME[5];
+        nbus->tx_buffer[10] = MODULE_NAME[6];
+        nbus->tx_buffer[11] = MODULE_NAME[7];
+        nbus->tx_length += 8;
+        // type
+        nbus->tx_buffer[12] = MODULE_TYPE[0];
+        nbus->tx_buffer[13] = MODULE_TYPE[1];
+        nbus->tx_buffer[14] = MODULE_TYPE[2];
+        nbus->tx_length += 3;
 
-            // Reference manual: Unique device ID registers
+        // uuid - reference manual: Unique device ID registers
 #if defined(STM32)
-            uint32_t(*unique_id_3) = (uint32_t *)(0x1FF80064); // BASE address + 0x14 0ffset
+        uint32_t(*unique_id_3) = (uint32_t *)(0x1FF80064); // BASE address + 0x14 0ffset
 #elif defined(ESP32) || defined(NRF)
-            uint32_t unique_id_3 = 0x12345678;
+        uint32_t unique_id_3 = 0x12345678;
 #endif
-            nbus->tx_buffer[15] = ((uint8_t *)(&unique_id_3))[0];
-            nbus->tx_buffer[16] = ((uint8_t *)(&unique_id_3))[1];
-            nbus->tx_buffer[17] = ((uint8_t *)(&unique_id_3))[2];
-            nbus->tx_buffer[18] = ((uint8_t *)(&unique_id_3))[3];
-            nbus->tx_length += 4;
-            // fw version
-            nbus->tx_buffer[19] = VERSION_FW[0];
-            nbus->tx_buffer[20] = '.';
-            nbus->tx_buffer[21] = VERSION_FW[1];
-            nbus->tx_length += 3;
-            // hw version
-            nbus->tx_buffer[22] = VERSION_HW[0];
-            nbus->tx_buffer[23] = '.';
-            nbus->tx_buffer[24] = VERSION_HW[1];
-            nbus->tx_length += 3;
-            // module memory
-            nbus->memoryInterface->getId(&nbus->tx_buffer[25]);
-            nbus->tx_length += 8;
-            break;
-        }
-
-        case INFO_FORMAT: {
-            uint8_t sensor_cnt = nbus->interface->getSensorCount();
+        nbus->tx_buffer[15] = ((uint8_t *)(&unique_id_3))[0];
+        nbus->tx_buffer[16] = ((uint8_t *)(&unique_id_3))[1];
+        nbus->tx_buffer[17] = ((uint8_t *)(&unique_id_3))[2];
+        nbus->tx_buffer[18] = ((uint8_t *)(&unique_id_3))[3];
+        nbus->tx_length += 4;
+        // fw version
+        nbus->tx_buffer[19] = VERSION_FW[0];
+        nbus->tx_buffer[20] = '.';
+        nbus->tx_buffer[21] = VERSION_FW[1];
+        nbus->tx_length += 3;
+        // hw version
+        nbus->tx_buffer[22] = VERSION_HW[0];
+        nbus->tx_buffer[23] = '.';
+        nbus->tx_buffer[24] = VERSION_HW[1];
+        nbus->tx_length += 3;
+        // module memory
+        nbus->memoryInterface->getId(&nbus->tx_buffer[25]);
+        nbus->tx_length += 8;
+    }
+    break;
+       
 
-            for (int8_t i = 0; i < sensor_cnt; ++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;
-                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];
-            }
+    case CMD_FORMAT: {
+        uint8_t sensor_cnt = nbus->interface->getSensorCount();
 
-            nbus->tx_length += 4 * sensor_cnt;
-            break;
-        }
+        for (int8_t i = 0; i < sensor_cnt; ++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;
+            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;
     }
     break;
 
@@ -182,28 +179,30 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
     break;
 
     case CMD_PARAM: {
-        // same as nbus_unicastToSensorSet
-        int32_t param_value =
-            nbus->rx_buffer[4] | nbus->rx_buffer[5] << 8 | nbus->rx_buffer[6] << 16 << nbus->rx_buffer[7] << 23;
-        nBus_param_t p = nbus->interface->setParam(0, (nBus_param_t)nbus->rx_buffer[3], param_value);
-        if (p == PARAM_NONE)
+        
+        uint8_t rx_payload = nbus->rx_length - META_SIZE;
+        
+        // empty or wrong number of parameters
+        if (rx_payload == 0 || rx_payload % 5 != 0)
         {
-            setErrorResponse(nbus, PARAM_NOT_IMPLEMENTED);
+            setErrorResponse(nbus, ILLEGAL_FUNCTION_PARAM);
             break;
         }
-        nbus->tx_buffer[4] = OK_CODE;
-        nbus->tx_length += 1;
-    }
-    break;
-
-    case CMD_DATA: {
-        nbus->tx_buffer[4] = nbus->interface->setData(&nbus->rx_buffer[3]);
-        if (nbus->tx_buffer[4] != OK_CODE)
+        else
         {
-            nbus->function_code.error = 1;
-        }
+            uint8_t param_id;
+            uint32_t param_value;
+            
+            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];
 
-        nbus->tx_length += 1;
+                nbus->tx_buffer[4 + 2 * i] = param_id;
+                nbus->tx_buffer[5 + 2 * i] = nbus->interface->setParam(0, param_id, param_value);
+                nbus->tx_length += 2;
+            }
+        }
     }
     break;
 
@@ -221,12 +220,18 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus)
 
     case CMD_CALIBRATE: {
         nbus->hw_platform->led_on();
-        nbus->tx_buffer[4] = nbus->interface->calibrate(0, 0, NULL);
+        nbus->tx_buffer[4] = nbus->interface->calibrate(0);
         nbus->tx_length += 1;
         nbus->hw_platform->led_off();
     }
     break;
 
+    case CMD_DATA: {
+
+        nbus->tx_length += nbus->interface->setData(&nbus->rx_buffer[3], nbus->rx_length - META_SIZE, &nbus->tx_buffer[4]);
+    }
+    break;
+
     case CMD_RESET: {
         // POZOR!  cas fomatovania: 0.3s (pri 1W pamati)
         memory_params_format();

src/nbus_slave_sensor_unicast.c

@@ -4,7 +4,7 @@
 
 void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
 {
-    nBus_sensorType_t sensor_type = nbus->interface->getType(nbus->sensorInfo.address);
+    nBus_sensorType_t sensor_type = nbus->interface->getType(nbus->rx_buffer[1]); // nbus->rx_buffer[1] is whole address with type
 
     if (sensor_type == TYPE_UNKNOWN) // handle bad sensor address
     {
@@ -14,24 +14,17 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
 
     switch (nbus->function_code.function)
     {
-    case CMD_SENSOR_TYPE: {
-        nbus->tx_buffer[4] = sensor_type;
-        nbus->tx_length += 1;
-        break;
-    }
-
     case CMD_PARAM: {
-        if (nbus->rx_length >= 5) // get concrete param
+        if (nbus->rx_length == META_SIZE) // get concrete param
         {
-            if (nbus->interface->hasParam(nbus->sensorInfo.address, (nBus_param_t)nbus->rx_buffer[3]) ==
-                0) // handle non-existing param
+            if (nbus->interface->hasParam(nbus->rx_buffer[1], (nBus_param_t)nbus->rx_buffer[3]) == 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->sensorInfo.address, (nBus_param_t)nbus->rx_buffer[3]);
+            int32_t param_value = nbus->interface->getParam(nbus->rx_buffer[1], (nBus_param_t)nbus->rx_buffer[3]); // 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);
@@ -40,16 +33,13 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
         }
         else // get all params
         {
-            nBus_param_t *params = nbus_interface_allParams();
-            for (uint8_t i = 0; i < nbus_interface_allParamsCount(); i++)
+            for (uint8_t i = 0; i < _NBUS_PARAM_COUNT; i++)
             {
-                if (nbus->interface->hasParam(nbus->sensorInfo.address, params[i]))
+                if (nbus->interface->hasParam(nbus->rx_buffer[1], i))
                 {
-                    int32_t param_value = nbus->interface->getParam(nbus->sensorInfo.address, params[i]);
-                    nbus->tx_buffer[4 + 5 * i] = params[i]; // param id
-                    // nbus->tx_buffer[5+2*i] =
-                    // nbus->interface->getParam(nbus->sensorInfo.address, params[i]);
-                    nbus->tx_buffer[5 + 5 * i] = (uint8_t)(param_value & 0xFF);
+                    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);
@@ -62,9 +52,9 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
     break;
 
     case CMD_DATA: {
-        if (nbus->measure_active == MEASURE_RUNNING)
+        if (nbus->interface->device_ready())
         {
-            uint8_t cnt = nbus->interface->getData(nbus->sensorInfo.address, &nbus->tx_buffer[4]);
+            uint8_t cnt = nbus->interface->getData(nbus->rx_buffer[1], &nbus->tx_buffer[4]);
             if (cnt == 0)
             {
                 setErrorResponse(nbus, DEVICE_BUSY);
@@ -79,19 +69,20 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
     }
     break;
 
-    case CMD_INFO: {
-        switch (nbus->rx_buffer[3])
-        {
-        case INFO_FORMAT: {
-            nBus_sensorFormat_t format = nbus->interface->getSensorFormat(nbus->sensorInfo.address);
-            uint8_t *format_ptr = (uint8_t *)&format;
-            nbus->tx_buffer[4] = nbus->sensorInfo.address;
-            nbus->tx_buffer[5] = format_ptr[0];
-            nbus->tx_buffer[6] = format_ptr[1];
-            nbus->tx_buffer[7] = format_ptr[2];
-            nbus->tx_length += 4;
-        }
-        }
+    case CMD_SENSOR_TYPE: {
+        nbus->tx_buffer[4] = sensor_type;
+        nbus->tx_length += 1;
+        break;
+    }
+
+    case CMD_FORMAT: {
+        nBus_sensorFormat_t format = nbus->interface->getSensorFormat(nbus->rx_buffer[1]);
+        uint8_t *format_ptr = (uint8_t *)&format;
+        nbus->tx_buffer[4] = nbus->rx_buffer[1]; // sensor address and type
+        nbus->tx_buffer[5] = format_ptr[0];
+        nbus->tx_buffer[6] = format_ptr[1];
+        nbus->tx_buffer[7] = format_ptr[2];
+        nbus->tx_length += 4;
     }
     break;
 
@@ -103,7 +94,7 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus)
 
 void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
 {
-    nBus_sensorType_t sensor_type = nbus->interface->getType(nbus->sensorInfo.address);
+    nBus_sensorType_t sensor_type = nbus->interface->getType(nbus->rx_buffer[1]); // nbus->rx_buffer[1] is whole address with type
 
     if (sensor_type == TYPE_UNKNOWN) // handle bad sensor address
     {
@@ -114,51 +105,58 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus)
     switch (nbus->function_code.function)
     {
     case CMD_PARAM: {
-        if (!nbus->interface->hasParam(nbus->sensorInfo.address, (nBus_param_t)nbus->rx_buffer[3]))
+        
+        uint8_t rx_payload = nbus->rx_length - META_SIZE;
+        
+        // empty or wrong number of parameters
+        if (rx_payload == 0 || rx_payload % 5 != 0)
         {
-            setErrorResponse(nbus, PARAM_NOT_IMPLEMENTED);
+            setErrorResponse(nbus, ILLEGAL_FUNCTION_PARAM);
             break;
         }
-
-        int32_t param_value =
-            nbus->rx_buffer[4] | nbus->rx_buffer[5] << 8 | nbus->rx_buffer[6] << 16 << nbus->rx_buffer[7] << 23;
-        nBus_param_t p =
-            nbus->interface->setParam(nbus->sensorInfo.address, (nBus_param_t)nbus->rx_buffer[3], param_value);
-        if (p == PARAM_NONE)
+        else
         {
-            setErrorResponse(nbus, ILLEGAL_DATA_VALUE);
-            break;
+            uint8_t param_id;
+            uint32_t param_value;
+            
+            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];
+
+                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_length += 2;
+            }
         }
-        nbus->tx_buffer[4] = OK_CODE;
-        nbus->tx_length += 1;
     }
     break;
 
     case CMD_CALIBRATE: {
         nbus->hw_platform->led_on();
-        nbus->tx_buffer[4] = nbus->interface->calibrate(nbus->sensorInfo.address, 0, NULL);
+        nbus->tx_buffer[4] = nbus->interface->calibrate(nbus->rx_buffer[1]);
         nbus->tx_length += 1;
         nbus->hw_platform->led_off();
         break;
     }
 
     case CMD_DATA: {
-        nbus->tx_buffer[4] = nbus->interface->setData(&nbus->rx_buffer[3]);
-        if (nbus->tx_buffer[4] != OK_CODE)
+        if (nbus->sensorInfo.type == 0) // if device is output only (sensor)
         {
-            nbus->function_code.error = 1;
+            setErrorResponse(nbus, ERR_OUTPUT_ONLY);
+            break;
         }
-        nbus->tx_length += 1;
+
+        nbus->tx_length += nbus->interface->setData(&nbus->rx_buffer[3], nbus->rx_length - META_SIZE, &nbus->tx_buffer[4]);
     }
     break;
 
     case CMD_STORE: {
-        nBus_param_t *all_params = nbus_interface_allParams();
-        for (uint32_t i = 0; i < nbus_interface_allParamsCount(); i++)
+        for (uint32_t i = 0; i < _NBUS_PARAM_COUNT; i++)
         {
-            if (nbus->interface->hasParam(nbus->sensorInfo.address, all_params[i]))
+            if (nbus->interface->hasParam(nbus->sensorInfo.address, i))
             {
-                sensor_store_param(nbus, nbus->sensorInfo.address, all_params[i]);
+                sensor_store_param(nbus, nbus->sensorInfo.address, i);
                 // param_value = nbus->interface->getParam(nbus->sensorInfo.address,
                 // all_params[i]);
                 // nbus->memoryInterface->storeParam(nbus->sensorInfo.address,