non persistent memory for parameters

Inc/nbus_memory.h

@@ -28,14 +28,14 @@ typedef struct {
   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
+   * @brief Zapíše 4B/2B/1B hodnotu na adresu
    * @param uint32_t data dáta
    * @param uint16_t address adresa v pamati. Povolený rozsah: 0-0x09FF
+   * @param uint8_t length dĺžka zapisovaných dát
    */
-  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 (*write_data)(uint8_t *data, uint16_t address, uint8_t length);
   uint8_t (*read_id)(uint8_t *);
   uint32_t (*get_capacity)(void);
 } nBus_MemoryDriver;
@@ -72,9 +72,9 @@ void nbus_memory_init(nBus_MemoryDriver *driver);
 /**
  * @brief Store sensor parameter.
  */
-nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
+nBus_memoryState_t nbus_memory_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);
+uint32_t nbus_memory_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);

Src/app_bridge.c

@@ -8,15 +8,15 @@
 
 nBus_param_t allParams[] = {PARAM_TIMEBASE, PARAM_RESOLUTION, PARAM_GAIN,
                             PARAM_OFFSET,   PARAM_SAMPLERATE, PARAM_RANGE,
-                            PARAM_FILTER,   PARAM_RANGE0};
+							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 8; }
+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 7; }
+uint8_t nbus_interface_allTypesCount() { return sizeof(nBus_param_t)/sizeof(nBus_sensorType_t); }

Src/nbus_app.c

@@ -218,7 +218,7 @@ void nbus_init_app(void *hw_interface, void *hw_config) {
 /**
  * @brief Init memory driver for storing module/sensor parameters.
  * Implementation of memory driver is independent from nBus. To provide
- * nonvolatile parameters store, is nneded implement this driver.
+ * nonvolatile parameters store, is needed implement this driver.
  * @param memDriver Memory driver for bas operation: read/write 1/2/4 byte
  * from/to memory
  * @todo implement capacity parameter
@@ -229,6 +229,21 @@ void nbus_init_memory_driver(nBus_MemoryDriver *memDriver) {
   nbus_blink_LED(100);
 
   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++) {
+		  if (nbus_is_param_active(index, params[paramIndex])) {
+			  if (nBus.interface->hasParam(index, params[paramIndex])) {
+				  paramValue = nbus_memory_read_param(index, params[paramIndex]);
+				  nBus.interface->setParam(index, params[paramIndex], paramValue);
+			  }
+		  }
+	  }
+  }
+
 }
 
 /**

Src/nbus_memory.c

@@ -10,7 +10,7 @@
 nBus_MemoryDriver *memoryImplementation;
 
 nBus_memoryInterface_t memory_itnerface = {
-    nbus_store_param,      nbus_read_param, nbus_is_param_active,
+	nbus_memory_store_param,  nbus_memory_read_param, nbus_is_param_active,
     nbus_read_header_data, nbus_memory_id,  nbus_get_capacity};
 nBus_memoryHeader_t memoryHeader;
 
@@ -18,6 +18,8 @@ nBus_memoryInterface_t *getnbusMemoryInterface(void) {
   return &memory_itnerface;
 }
 
+uint8_t memory_buffer[32];
+
 void nbus_memory_init(nBus_MemoryDriver *driver) {
   memoryImplementation = driver;
   for (uint32_t i = 0; i < 64; i++) {
@@ -28,7 +30,27 @@ void nbus_memory_init(nBus_MemoryDriver *driver) {
   }
 }
 
-nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
+uint8_t ubus_memory_write4B(uint32_t data, uint16_t adr) {
+	memory_buffer[0] = data>>24;
+	memory_buffer[1] = (data>>16) & 0xFF;
+	memory_buffer[2] = (data>>8) & 0xFF;
+	memory_buffer[3] = (data) & 0xFF;
+    return memoryImplementation->write_data(memory_buffer, adr, 4);
+}
+
+uint8_t ubus_memory_write2B(uint16_t data, uint16_t adr) {
+	memory_buffer[0] = (data>>8) & 0xFF;
+	memory_buffer[1] = (data) & 0xFF;
+    return memoryImplementation->write_data(memory_buffer, adr, 2);
+}
+
+uint8_t ubus_memory_write1B(uint8_t data, uint16_t adr) {
+	memory_buffer[0] = (data) & 0xFF;
+	return memoryImplementation->write_data(memory_buffer, adr, 1);
+}
+
+
+nBus_memoryState_t nbus_memory_store_param(uint8_t sensor_index, uint8_t param_name,
                                     uint32_t param_value) {
   if (param_name >= 16) {
     return MEMORY_STORE_FAIL;
@@ -39,7 +61,7 @@ nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
   }
 
   /*
-   * Write information abou validity of parameter for sensor 'sensor_index'. 0 -
+   * Write information about validity of parameter for sensor 'sensor_index'. 0 -
    * parameter not set, 0xAA - parameter is setted
    */
   uint8_t address_offset = getParameterHeaderOffset(sensor_index, param_name);
@@ -58,14 +80,14 @@ nBus_memoryState_t nbus_store_param(uint8_t sensor_index, uint8_t param_name,
     break;
   }
 
-  memoryImplementation->write_byte(
+  ubus_memory_write1B(
       *(uint8_t *)(&memoryHeader.params_map[address_offset]), sensor_index);
-  return memoryImplementation->write_word(param_value, addr) == 0
+  return ubus_memory_write4B(param_value, addr) == 0
              ? MEMORY_STORE_OK
              : MEMORY_STORE_FAIL;
 }
 
-uint32_t nbus_read_param(uint8_t sensor_index, uint8_t param_name) {
+uint32_t nbus_memory_read_param(uint8_t sensor_index, uint8_t param_name) {
   if (param_name >= 16) {
     return ERROR_VALUE_I32;
   }
@@ -123,8 +145,13 @@ uint8_t nbus_is_param_active(uint8_t sensor_index, uint8_t param_name) {
 
 // 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 empty_data[32] = {
+			0,0,0,0,0,0,0,0,
+			0,0,0,0,0,0,0,0,
+			0,0,0,0,0,0,0,0,
+			0,0,0,0,0,0,0,0};
+  for (uint32_t adr = 0; adr < 64; adr += 32) {
+    memoryImplementation->write_data(empty_data, adr, 32);
   }
 }
 

Src/nbus_slave_module_unicast.c

@@ -146,7 +146,7 @@ void nbus_slave_unicastToModuleSet(nBus_TypeDef *nbus) {
     nbus->tx_length += 1;
   }
   case CMD_RESET: {
-    // POZOR!  cas fomatovania: 0.9s
+    // POZOR!  cas fomatovania: 0.3s (pri 1W pamati)
     memory_params_format();
     nbus->tx_buffer[4] = OK_CODE;
     nbus->tx_length += 1;