device configuration prepared

cube/User/Inc/config.h

@@ -3,9 +3,10 @@
 
 #include <stdint.h>
 #include <spi.h>
+#include <assert.h>
 
-
+#define CONFIG_MAGIC 0xdead0004
-#define CONFIG_MAGIC 0xdead0003
+#define DEVICE_MAGIC 0xaffe0000
 
 typedef struct __attribute__((__packed__)) s_configBlock {
     uint32_t configMagic;
@@ -27,11 +28,12 @@ typedef struct __attribute__((__packed__)) s_configBlock {
 #define MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS 4
 
 typedef struct __attribute__((__packed__)) s_deviceBlock {
-  char deviceName[MBUSDEVICE_NAMELENGTH];
+    uint32_t deviceMagic;
-  uint8_t address;
+    char deviceName[MBUSDEVICE_NAMELENGTH];
-  int8_t consideredField[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS];
+    uint8_t address;
-  int32_t period;
+    int8_t consideredField[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS];
-  uint8_t filler[7];
+    int32_t period;
+    uint8_t filler[3];
 } t_deviceBlock;
 
 void configInit();

cube/User/Inc/eeprom.h

@@ -4,21 +4,47 @@
 #include <stdint.h>
 #include <spi.h>
 #include <config.h>
+#include <assert.h>
 
 
+
+#define EEPROM_WRITE_BLOCK_SIZE 32
+#define EEPROM_AFTER_WRITE_DELAY 7
+
+
+typedef struct __attribute__((__packed__)) s_eepromHeader {
+  uint32_t magic;
+  uint32_t writeCounter;
+} t_eepromHeader;
+static_assert((sizeof(t_eepromHeader) <= EEPROM_WRITE_BLOCK_SIZE), "t_eepromHeader has illegal size, must be less than or equal 32");
+
 typedef struct __attribute__((__packed__)) s_deviceStats {
     uint32_t totalRunningHours;
     uint32_t totalPowercycles;
     uint32_t totalRequests;
     uint32_t totalFailures;
 } t_deviceStats;
+static_assert((sizeof(t_deviceStats) <= EEPROM_WRITE_BLOCK_SIZE), "t_deviceStats has illegal size, must be less than or equal 32");
+
+static_assert((sizeof(t_configBlock) % 32 == 0), "t_configBlock has illegal size, must be dividable by 32");
+static_assert((sizeof(t_deviceBlock) % 32 == 0), "t_deviceBlock has illegal size, must be dividable by 32");
+
+
+#define EEPROM_BASE_ADDR 0
+#define EEPROM_DEVICE_STATS_ADDR 32
+#define EEPROM_CONFIG_BLOCK_ADDR 64
+#define EEPROM_DEVICE_BLOCK_BASE_ADDR (EEPROM_CONFIG_BLOCK_ADDR + sizeof(t_configBlock))
+
+
 
 void eepromInit();
 void eepromWrite(uint16_t addr, uint8_t *buf, uint8_t len);
 void eepromRead(uint16_t addr, uint8_t *buf, uint8_t len);
 void eepromSpiTxCpltCallback(SPI_HandleTypeDef *hspi);
 t_deviceStats* getGlobalDeviceStats();
-void eepromReadConfigBlock(uint8_t blockNum, t_configBlock *destConfigBlock);
+void eepromReadConfigBlock(t_configBlock *destConfigBlock);
-void eepromWriteConfigBlock(uint8_t blockNum, t_configBlock *srcConfigBlock);
+void eepromWriteConfigBlock(t_configBlock *srcConfigBlock);
+void eepromReadDeviceBlock(uint8_t blockNum, t_deviceBlock *destDeviceBlock);
+void eepromWriteDeviceBlock(uint8_t blockNum, t_deviceBlock *srcDeviceBlock);
 
 #endif /* EEPROM_H_ */

cube/User/Src/config.c

@@ -16,10 +16,28 @@ t_configBlock defaultConfigBlock = {
     .statusTopic = "IoT/MBGW3/Status",
     .mbusDataTopic = "IoT/MBGW3/Measurement",
     .syslogServerName = "syslogserver",
-    .numOfDeviceBlocks = 0,
+    .numOfDeviceBlocks = 2,
     .filler = { 0 }
 };
 
+t_deviceBlock defaultDeviceBlock[] = {
+    {
+        .deviceMagic = DEVICE_MAGIC,
+        .deviceName = "Total",
+        .address = 80,
+        .consideredField = { 0, 17, -1, -1 },
+        .period = 10,
+        .filler = { 0, 0, 0 }
+    },
+    {
+        .deviceMagic = DEVICE_MAGIC,
+        .deviceName = "Computer",
+        .address = 85,
+        .consideredField = { 0, 4, 2, 3 },
+        .period = 10,
+        .filler = { 0, 0, 0 }
+    }
+};
 
 t_configBlock mainConfigBlock;
 
@@ -32,18 +50,21 @@ t_configBlock* getConfig() {
 
 void configInit() {
     coloredMsg(LOG_BLUE, false, "cfg ci Reading configuration block from eeprom");
-    eepromReadConfigBlock(0, &mainConfigBlock);
+    eepromReadConfigBlock(&mainConfigBlock);
 
     if (mainConfigBlock.configMagic != CONFIG_MAGIC) {
         coloredMsg(LOG_BLUE, false, "cfg ci Invalid configuration block read from eeprom");
 
-        eepromWriteConfigBlock(0, &defaultConfigBlock);
+        eepromWriteConfigBlock(&defaultConfigBlock);
         coloredMsg(LOG_BLUE, false, "cfg ci Default configuration block written to eeprom");
 
-        coloredMsg(LOG_BLUE, false, "cfg ci Reading configuration block from eeprom again");
+        eepromWriteDeviceBlock(0, &defaultDeviceBlock[0]);
-        eepromReadConfigBlock(0, &mainConfigBlock);
+        eepromWriteDeviceBlock(1, &defaultDeviceBlock[1]);
-    }
+        coloredMsg(LOG_BLUE, false, "cfg ci Default device blocks written to eeprom");
 
+        coloredMsg(LOG_BLUE, false, "cfg ci Reading configuration block from eeprom again");
+        eepromReadConfigBlock(&mainConfigBlock);
+    }
     coloredMsg(LOG_BLUE, false, "cfg ci configMagic:         %lx", mainConfigBlock.configMagic);
     coloredMsg(LOG_BLUE, false, "cfg ci deviceName:          %s", mainConfigBlock.deviceName);
     coloredMsg(LOG_BLUE, false, "cfg ci MAC address:         %02x:%02x:%02x:%02x:%02x:%02x", mainConfigBlock.macAddress[0], 
@@ -60,4 +81,17 @@ void configInit() {
     coloredMsg(LOG_BLUE, false, "cfg ci mbusDataTopic:       %s", mainConfigBlock.mbusDataTopic);
     coloredMsg(LOG_BLUE, false, "cfg ci syslog server:       %s", mainConfigBlock.syslogServerName);
     coloredMsg(LOG_BLUE, false, "cfg ci device block cnt:    %d", mainConfigBlock.numOfDeviceBlocks);
+
+    for (uint8_t i = 0; i < mainConfigBlock.numOfDeviceBlocks; i++) {
+        t_deviceBlock tmpDeviceBlock;
+        eepromReadDeviceBlock(i, &tmpDeviceBlock);
+        coloredMsg(LOG_BLUE, false, "cfg ci device %d: ", i);
+        coloredMsg(LOG_BLUE, false, "  Name: %s, Address: %d, Period: %d", 
+                   tmpDeviceBlock.deviceName, tmpDeviceBlock.address, tmpDeviceBlock.period);
+        coloredMsg(LOG_BLUE, false, "  Considered Fields: %d %d %d %d",
+                   tmpDeviceBlock.consideredField[0],
+                   tmpDeviceBlock.consideredField[1],
+                   tmpDeviceBlock.consideredField[2],
+                   tmpDeviceBlock.consideredField[3]);
+    }
 }

cube/User/Src/eeprom.c

@@ -22,21 +22,18 @@ static const uint8_t EEPROM_WREN = 0x06;
 // static const uint8_t EEPROM_WRSR = 0x01;
 
 
-static const uint32_t EEPROM_MAGIC = 0xaffe0008;
+static const uint32_t EEPROM_MAGIC = 0xaffe0009;
+
+
+static const uint16_t EEPROM_HEADER_ADDR = EEPROM_BASE_ADDR;
 
 
 typedef union {
-  struct __attribute__((__packed__)) s_eepromHeader {
+  t_eepromHeader s;
-    uint32_t magic;
-    uint32_t writeCounter;
-    uint8_t activeBlock;
-  } s;
   uint8_t b[sizeof(struct s_eepromHeader)];
-} t_eepromHeader;
+} t_eepromHeaderBlock;
-
-static const uint16_t EEPROM_HEADER_ADDR = 0;
-static t_eepromHeader eepromHeader;
 
+static t_eepromHeaderBlock eepromHeader;
 
 
 typedef union {
@@ -44,14 +41,14 @@ typedef union {
   uint8_t b[sizeof(t_deviceStats)];
 } t_deviceStatsBlock;
 
-static const uint16_t DEVICE_STATS_ADDR = 32;
+static const uint16_t DEVICE_STATS_ADDR = EEPROM_DEVICE_STATS_ADDR;
 static t_deviceStatsBlock deviceStats;
 
-static const uint8_t NUM_OF_BLOCKS = 2;
+static const uint16_t CONFIG_BLOCK_ADDR = EEPROM_CONFIG_BLOCK_ADDR;
-static const uint16_t BLOCK_ADDR[] = { 64, 4128 };
+static const uint16_t DEVICE_BLOCK_ADDR = EEPROM_DEVICE_BLOCK_BASE_ADDR;
+
+
 
-#define EEPROM_WRITE_BLOCK_SIZE 32
-#define EEPROM_AFTER_WRITE_DELAY 7
 
 typedef union {
   struct __attribute__((__packed__)) s_spiMsg {
@@ -134,17 +131,36 @@ static void eepromHourlyUpdateDeviceStats(void *handle) {
   eepromWrite(DEVICE_STATS_ADDR, deviceStats.b, sizeof(deviceStats));
 }
 
-void eepromReadConfigBlock(uint8_t blockNum, t_configBlock *destConfigBlock) {
+void eepromReadConfigBlock(t_configBlock *destConfigBlock) {
-  static_assert((sizeof(*destConfigBlock) % EEPROM_WRITE_BLOCK_SIZE == 0), "config block has illegal size, must be dividable by 32");
+//  static_assert((sizeof(*destConfigBlock) % EEPROM_WRITE_BLOCK_SIZE == 0), "config block has illegal size, must be dividable by 32");
 
   for (uint8_t i = 0; i < (sizeof(*destConfigBlock) / EEPROM_WRITE_BLOCK_SIZE); i++) {
-    eepromRead(BLOCK_ADDR[blockNum] + (i * EEPROM_WRITE_BLOCK_SIZE), ((uint8_t*)destConfigBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), EEPROM_WRITE_BLOCK_SIZE);
+    eepromRead(CONFIG_BLOCK_ADDR + (i * EEPROM_WRITE_BLOCK_SIZE), ((uint8_t*)destConfigBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), EEPROM_WRITE_BLOCK_SIZE);
   }
 }
 
-void eepromWriteConfigBlock(uint8_t blockNum, t_configBlock *srcConfigBlock) {
+void eepromWriteConfigBlock(t_configBlock *srcConfigBlock) {
   for (uint8_t i = 0; i < (sizeof(*srcConfigBlock) / EEPROM_WRITE_BLOCK_SIZE); i++) {
-    eepromWrite(BLOCK_ADDR[blockNum] + (i * EEPROM_WRITE_BLOCK_SIZE), ((uint8_t*)srcConfigBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), EEPROM_WRITE_BLOCK_SIZE);
+    eepromWrite(CONFIG_BLOCK_ADDR + (i * EEPROM_WRITE_BLOCK_SIZE), ((uint8_t*)srcConfigBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), EEPROM_WRITE_BLOCK_SIZE);
+    eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY);
+  }
+}
+
+void eepromReadDeviceBlock(uint8_t blockNum, t_deviceBlock *destDeviceBlock) {
+  static_assert((sizeof(*destDeviceBlock) % EEPROM_WRITE_BLOCK_SIZE == 0), "device block has illegal size, must be dividable by 32");
+
+  for (uint8_t i = 0; i < (sizeof(*destDeviceBlock) / EEPROM_WRITE_BLOCK_SIZE); i++) {
+    eepromRead(DEVICE_BLOCK_ADDR + (blockNum * sizeof(*destDeviceBlock)) + (i * EEPROM_WRITE_BLOCK_SIZE), 
+               ((uint8_t*)destDeviceBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), 
+               EEPROM_WRITE_BLOCK_SIZE);
+  }
+}
+
+void eepromWriteDeviceBlock(uint8_t blockNum, t_deviceBlock *srcDeviceBlock) {
+  for (uint8_t i = 0; i < (sizeof(*srcDeviceBlock) / EEPROM_WRITE_BLOCK_SIZE); i++) {
+    eepromWrite(DEVICE_BLOCK_ADDR + (blockNum * sizeof(*srcDeviceBlock)) + (i * EEPROM_WRITE_BLOCK_SIZE), 
+                ((uint8_t*)srcDeviceBlock) + (i * EEPROM_WRITE_BLOCK_SIZE), 
+                EEPROM_WRITE_BLOCK_SIZE);
     eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY);
   }
 }
@@ -169,20 +185,13 @@ void eepromInit() {
     eepromWrite(DEVICE_STATS_ADDR, deviceStats.b, sizeof(deviceStats));
     eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY);
 
-    uint8_t emptyBlock[32];
+    uint8_t emptyBlock[EEPROM_WRITE_BLOCK_SIZE];
     memset(emptyBlock, 0, sizeof(emptyBlock));
-    for (uint8_t i = 0; i < NUM_OF_BLOCKS; i++) {
+    eepromWrite(CONFIG_BLOCK_ADDR, emptyBlock, EEPROM_WRITE_BLOCK_SIZE);
-      for (uint8_t j = 0; j <= 127; j++) {
+    eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY);
-        uint16_t addr = BLOCK_ADDR[i] + sizeof(emptyBlock) * j;
+    logMsg("eeI, config block initialized");
-        eepromWrite(addr, emptyBlock, sizeof(emptyBlock));
-        eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY);
-      }
-    }
-    logMsg("eeI, storage blocks initialized");
-
 
     eepromHeader.s.magic = EEPROM_MAGIC;
-    eepromHeader.s.activeBlock = 0;
     eepromHeader.s.writeCounter = 1;
     logMsg("eeI, about to write header for the first time");
     eepromWrite(EEPROM_HEADER_ADDR, eepromHeader.b, sizeof(eepromHeader));