store param interface

Inc/nbus_app.h

@@ -25,7 +25,7 @@ extern "C" {
 void nbus_init(nBusAppInterface_t *interface, nBusPlatformInterface_t *hw);
 void nbus_init_app(void *hw_interface, void *hw_config);
 void nbus_stack(void);
-void nbus_init_memory_driver(nBus_MemoryDriver *memDriver, uint16_t capacity);
+void nbus_init_memory_driver(nBus_MemoryDriver *memDriver);
 
 void nbus_cb_UART_RX(int);
 void nbus_cb_TIM_periodElapsed(void);

Inc/nbus_memory.h

@@ -10,10 +10,24 @@
 
 #include "mcu_platform.h"
 
+#define ERROR_VALUE_I32 0x7FFFFFFF
+#define MODULE_SENSORS_ADDRESS_OFFSET 64
+#define MODULE_PARAMS_COUNT 16
+#define MODULE_PARAM_SIZE 4
+
+#define GET_PARAM_ADDRESS(sensor, param)                                       \
+  (MODULE_SENSORS_ADDRESS_OFFSET +                                             \
+   (sensor)*MODULE_PARAMS_COUNT * MODULE_PARAM_SIZE +                          \
+   (param)*MODULE_PARAM_SIZE)
+
+#define PARAMETER_VALID 0b10
+#define PARAMETER_UNSET 0b01
+
 typedef struct {
   uint8_t (*init)(void *, uint16_t);
   uint32_t (*read_word)(uint16_t);
   uint16_t (*read_half_word)(uint16_t);
+  uint8_t (*read_byte)(uint16_t);
   /**
    * @brief Zapíše 4B hodnotu na adresu
    * @param uint32_t data dáta
@@ -21,7 +35,9 @@ typedef struct {
    */
   uint8_t (*write_word)(uint32_t data, uint16_t address);
   uint8_t (*write_half_word)(uint16_t, uint16_t);
+  uint8_t (*write_byte)(uint8_t, uint16_t);
   uint8_t (*read_id)(uint8_t *);
+  uint32_t (*get_capacity)(void);
 } nBus_MemoryDriver;
 
 typedef enum {
@@ -32,10 +48,24 @@ typedef enum {
 typedef struct {
   uint8_t (*storeParam)(uint8_t sensor_index, uint8_t param_name,
                         uint32_t param_value);
-  uint32_t (*getParam)(uint8_t sensor_index, uint8_t param_name);
+  uint32_t (*readParam)(uint8_t sensor_index, uint8_t param_name);
+  uint8_t (*isParamActive)(uint8_t sensor_index, uint8_t param_name);
+  void (*readHeaderData)(void);
   uint8_t (*getId)(uint8_t *);
+  uint32_t (*getCapacity)(void);
 } nBus_memoryInterface_t;
 
+typedef struct __attribute__((packed)) {
+  uint8_t param0 : 2;
+  uint8_t param1 : 2;
+  uint8_t param2 : 2;
+  uint8_t param3 : 2;
+} nBus_MemorySensorParam_t;
+
+typedef struct {
+  nBus_MemorySensorParam_t params_map[64];
+} nBus_memoryHeader_t;
+
 nBus_memoryInterface_t *getnbusMemoryInterface(void);
 
 void nbus_memory_init(nBus_MemoryDriver *driver);
@@ -45,7 +75,13 @@ void nbus_memory_init(nBus_MemoryDriver *driver);
 nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
                                     uint32_t param_value);
 uint32_t nbus_read_param(uint8_t sensor_index, uint8_t param_name);
-
 uint8_t nbus_memory_id(uint8_t *);
+uint32_t nbus_get_capacity(void);
+void nbus_read_header_data(void);
+void memory_params_format(void);
+
+uint8_t nbus_is_param_active(uint8_t sensor_index, uint8_t param_name);
+
+uint8_t getParameterHeaderOffset(uint8_t sensor_index, uint8_t param_name);
 
 #endif /* MODULES_NBUS_INC_NBUS_MEMORY_H_ */

Inc/nbus_slave.h

@@ -22,6 +22,8 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus);
 void nbus_slave_unicastToModuleSet(nBus_TypeDef *nBus);
 
 void nbus_slave_broadcast(nBus_TypeDef *nBus, nBusCommandType_t request_type);
+void sensor_store_param(nBus_TypeDef *nbus, uint8_t sensor_index,
+                        uint8_t param_name);
 #endif
 
 #endif

Src/app_bridge.c

@@ -15,7 +15,7 @@ nBus_sensorType_t allTypes[] = {
 
 nBus_param_t *nbus_interface_allParams() { return allParams; }
 
-uint8_t nbus_interface_allParamsCount() { return 6; }
+uint8_t nbus_interface_allParamsCount() { return 8; }
 
 nBus_sensorType_t *nbus_interface_allTypes() { return allTypes; }
 

Src/app_dummy.c

@@ -50,7 +50,7 @@ uint8_t dummy_getData(uint8_t sensor_index, uint8_t *data) {
 uint8_t dummy_setData(uint8_t *data) { return 1; }
 
 int32_t dummy_getParam(uint8_t sensor_index, nBus_param_t param) {
-  return 0xAB;
+  return 0xABCD4567;
 }
 
 uint8_t dummy_hasParam(uint8_t sensor_index, nBus_param_t param) {

Src/nbus_app.c

@@ -221,13 +221,14 @@ void nbus_init_app(void *hw_interface, void *hw_config) {
  * nonvolatile parameters store, is nneded implement this driver.
  * @param memDriver Memory driver for bas operation: read/write 1/2/4 byte
  * from/to memory
- * @param capacity TBD
- * @todo imeplement capacity parameter
+ * @todo implement capacity parameter
  */
-void nbus_init_memory_driver(nBus_MemoryDriver *memDriver, uint16_t capacity) {
+void nbus_init_memory_driver(nBus_MemoryDriver *memDriver) {
   nbus_memory_init(memDriver);
   nBus.memoryInterface = getnbusMemoryInterface();
   nbus_blink_LED(100);
+
+  nBus.memoryInterface->readHeaderData();
 }
 
 /**

Src/nbus_memory.c

@@ -9,8 +9,10 @@
 
 nBus_MemoryDriver *memoryImplementation;
 
-nBus_memoryInterface_t memory_itnerface = {nbus_store_param, nbus_read_param,
-                                           nbus_memory_id};
+nBus_memoryInterface_t memory_itnerface = {
+    nbus_store_param,      nbus_read_param, nbus_is_param_active,
+    nbus_read_header_data, nbus_memory_id,  nbus_get_capacity};
+nBus_memoryHeader_t memoryHeader;
 
 nBus_memoryInterface_t *getnbusMemoryInterface(void) {
   return &memory_itnerface;
@@ -18,17 +20,114 @@ nBus_memoryInterface_t *getnbusMemoryInterface(void) {
 
 void nbus_memory_init(nBus_MemoryDriver *driver) {
   memoryImplementation = driver;
+  for (uint32_t i = 0; i < 64; i++) {
+    memoryHeader.params_map[i].param0 = PARAMETER_UNSET;
+    memoryHeader.params_map[i].param1 = PARAMETER_UNSET;
+    memoryHeader.params_map[i].param2 = PARAMETER_UNSET;
+    memoryHeader.params_map[i].param3 = PARAMETER_UNSET;
+  }
 }
 
 nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
                                     uint32_t param_value) {
-  return MEMORY_STORE_OK;
+  if (param_name >= 16) {
+    return MEMORY_STORE_FAIL;
+  }
+  uint16_t addr = GET_PARAM_ADDRESS(sensor_index, param_name);
+  if (addr > memoryImplementation->get_capacity()) {
+    return MEMORY_STORE_FAIL;
+  }
+
+  /*
+   * Write information abou validity of parameter for sensor 'sensor_index'. 0 -
+   * parameter not set, 0xAA - parameter is setted
+   */
+  uint8_t address_offset = getParameterHeaderOffset(sensor_index, param_name);
+  switch (param_name % 4) {
+  case 0:
+    memoryHeader.params_map[address_offset].param0 = PARAMETER_VALID;
+    break;
+  case 1:
+    memoryHeader.params_map[address_offset].param1 = PARAMETER_VALID;
+    break;
+  case 2:
+    memoryHeader.params_map[address_offset].param2 = PARAMETER_VALID;
+    break;
+  case 3:
+    memoryHeader.params_map[address_offset].param3 = PARAMETER_VALID;
+    break;
+  }
+
+  memoryImplementation->write_byte(
+      *(uint8_t *)(&memoryHeader.params_map[address_offset]), sensor_index);
+  return memoryImplementation->write_word(param_value, addr) == 0
+             ? MEMORY_STORE_OK
+             : MEMORY_STORE_FAIL;
 }
+
 uint32_t nbus_read_param(uint8_t sensor_index, uint8_t param_name) {
-  uint16_t adr = sensor_index + param_name;
-  return memoryImplementation->read_word(adr);
+  if (param_name >= 16) {
+    return ERROR_VALUE_I32;
+  }
+  uint16_t addr = GET_PARAM_ADDRESS(sensor_index, param_name);
+  if (addr > memoryImplementation->get_capacity()) {
+    return ERROR_VALUE_I32;
+  }
+  return memoryImplementation->read_word(addr);
+}
+
+void nbus_read_header_data(void) {
+  uint8_t data;
+  for (uint32_t adr = 0; adr < 63; adr += 4) {
+    data = memoryImplementation->read_byte(adr);
+    memoryHeader.params_map[adr + 0] = *(nBus_MemorySensorParam_t *)(&data);
+    data = memoryImplementation->read_byte(adr + 1);
+    memoryHeader.params_map[adr + 1] = *(nBus_MemorySensorParam_t *)(&data);
+    data = memoryImplementation->read_byte(adr + 2);
+    memoryHeader.params_map[adr + 2] = *(nBus_MemorySensorParam_t *)(&data);
+    data = memoryImplementation->read_byte(adr + 3);
+    memoryHeader.params_map[adr + 3] = *(nBus_MemorySensorParam_t *)(&data);
+  }
 }
 
 uint8_t nbus_memory_id(uint8_t *data) {
   return memoryImplementation->read_id(data);
 }
+
+uint32_t nbus_get_capacity(void) {
+  return memoryImplementation->get_capacity();
+}
+
+uint8_t nbus_is_param_active(uint8_t sensor_index, uint8_t param_name) {
+  uint8_t address_offset = getParameterHeaderOffset(sensor_index, param_name);
+  uint8_t is_active;
+  switch (param_name % 4) {
+  case 0:
+    is_active = memoryHeader.params_map[address_offset].param0;
+    break;
+  case 1:
+    is_active = memoryHeader.params_map[address_offset].param1;
+    break;
+  case 2:
+    is_active = memoryHeader.params_map[address_offset].param2;
+    break;
+  case 3:
+    is_active = memoryHeader.params_map[address_offset].param3;
+    break;
+  default:
+    is_active = 0;
+  }
+
+  return is_active;
+}
+
+// TODO pouzit upravenu funkciu z drivera: DS28EC20_writeMem
+void memory_params_format(void) {
+  for (uint32_t adr = 0; adr < 64; adr += 4) {
+    memoryImplementation->write_word(0x0, adr);
+  }
+}
+
+uint8_t getParameterHeaderOffset(uint8_t sensor_index, uint8_t param_name) {
+  return (sensor_index - 1) * 4 + param_name / 4;
+}

Src/nbus_slave_module_unicast.c

@@ -145,18 +145,25 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus) {
     nbus->tx_buffer[4] = OK_CODE;
     nbus->tx_length += 1;
   }
-
-  case CMD_STORE: {
-    if (nbus->interface->store != NULL) {
-      nbus->interface->store();
-      nbus->tx_buffer[4] = OK_CODE;
-    } else {
-      nbus->tx_buffer[4] = ILLEGAL_FUNCTION;
-    }
-
+  case CMD_RESET: {
+    // POZOR!  cas fomatovania: 0.9s
+    memory_params_format();
+    nbus->tx_buffer[4] = OK_CODE;
     nbus->tx_length += 1;
   } break;
 
+    /*
+      case CMD_STORE: {
+        if (nbus->interface->store != NULL) {
+          nbus->interface->store();
+          nbus->tx_buffer[4] = OK_CODE;
+        } else {
+          nbus->tx_buffer[4] = ILLEGAL_FUNCTION;
+        }
+
+        nbus->tx_length += 1;
+      } break;
+    */
   default: {
     setErrorResponse(nbus, ILLEGAL_FUNCTION);
   }

Src/nbus_slave_sensor_unicast.c

@@ -71,6 +71,7 @@ void nbus_slave_unicastToSensorGet(nBus_TypeDef *nbus) {
 }
 
 void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus) {
+  int32_t param_value;
   switch (nbus->function_code.function) {
   case CMD_PARAM: {
     if (!nbus->interface->hasParam(nbus->sensorInfo.address,
@@ -79,8 +80,8 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus) {
       break;
     }
 
-    int32_t param_value = nbus->rx_buffer[4] | nbus->rx_buffer[5] << 8 |
-                          nbus->rx_buffer[6] << 16 << nbus->rx_buffer[7] << 23;
+    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);
@@ -100,10 +101,33 @@ void nbus_slave_unicastToSensorSet(nBus_TypeDef *nbus) {
     nbus->tx_length += 1;
   } break;
 
+  case CMD_STORE: {
+    nBus_param_t *all_params = nbus_interface_allParams();
+    for (uint32_t i = 0; i < nbus_interface_allParamsCount(); i++) {
+      if (nbus->interface->hasParam(nbus->sensorInfo.address, all_params[i])) {
+        sensor_store_param(nbus, nbus->sensorInfo.address, all_params[i]);
+        // param_value = nbus->interface->getParam(nbus->sensorInfo.address,
+        // all_params[i]);
+        // nbus->memoryInterface->storeParam(nbus->sensorInfo.address,
+        // all_params[i], param_value);
+      }
+    }
+
+    nbus->tx_buffer[4] = 1;
+    nbus->tx_length += 1;
+
+  } break;
+
   default: {
     setErrorResponse(nbus, ILLEGAL_FUNCTION);
   }
   }
 }
 
+void sensor_store_param(nBus_TypeDef *nbus, uint8_t sensor_index,
+                        uint8_t param_name) {
+  uint32_t param_value = nbus->interface->getParam(sensor_index, param_name);
+  nbus->memoryInterface->storeParam(sensor_index, param_name, param_value);
+}
+
 #endif