From f22c821ca3e1e23728a67bc49af8e8c7bb275bde Mon Sep 17 00:00:00 2001 From: Wolfgang Hottgenroth Date: Mon, 30 Nov 2020 18:29:53 +0100 Subject: [PATCH] device configuration prepared --- cube/User/Inc/config.h | 16 +++++----- cube/User/Inc/eeprom.h | 30 ++++++++++++++++-- cube/User/Src/config.c | 46 +++++++++++++++++++++++---- cube/User/Src/eeprom.c | 71 ++++++++++++++++++++++++------------------ 4 files changed, 117 insertions(+), 46 deletions(-) diff --git a/cube/User/Inc/config.h b/cube/User/Inc/config.h index 62e9680..5b66644 100644 --- a/cube/User/Inc/config.h +++ b/cube/User/Inc/config.h @@ -3,9 +3,10 @@ #include #include +#include - -#define CONFIG_MAGIC 0xdead0003 +#define CONFIG_MAGIC 0xdead0004 +#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]; - uint8_t address; - int8_t consideredField[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS]; - int32_t period; - uint8_t filler[7]; + uint32_t deviceMagic; + char deviceName[MBUSDEVICE_NAMELENGTH]; + uint8_t address; + int8_t consideredField[MBUSDEVICE_NUM_OF_CONSIDEREDFIELDS]; + int32_t period; + uint8_t filler[3]; } t_deviceBlock; void configInit(); diff --git a/cube/User/Inc/eeprom.h b/cube/User/Inc/eeprom.h index 31f8c08..fae6274 100644 --- a/cube/User/Inc/eeprom.h +++ b/cube/User/Inc/eeprom.h @@ -4,21 +4,47 @@ #include #include #include +#include + +#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 eepromWriteConfigBlock(uint8_t blockNum, t_configBlock *srcConfigBlock); +void eepromReadConfigBlock(t_configBlock *destConfigBlock); +void eepromWriteConfigBlock(t_configBlock *srcConfigBlock); +void eepromReadDeviceBlock(uint8_t blockNum, t_deviceBlock *destDeviceBlock); +void eepromWriteDeviceBlock(uint8_t blockNum, t_deviceBlock *srcDeviceBlock); #endif /* EEPROM_H_ */ diff --git a/cube/User/Src/config.c b/cube/User/Src/config.c index 5a482fd..4ec4568 100644 --- a/cube/User/Src/config.c +++ b/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"); - eepromReadConfigBlock(0, &mainConfigBlock); - } + eepromWriteDeviceBlock(0, &defaultDeviceBlock[0]); + 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]); + } } \ No newline at end of file diff --git a/cube/User/Src/eeprom.c b/cube/User/Src/eeprom.c index 8f05735..0b47707 100644 --- a/cube/User/Src/eeprom.c +++ b/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 { - uint32_t magic; - uint32_t writeCounter; - uint8_t activeBlock; - } s; + t_eepromHeader s; uint8_t b[sizeof(struct s_eepromHeader)]; -} t_eepromHeader; - -static const uint16_t EEPROM_HEADER_ADDR = 0; -static t_eepromHeader eepromHeader; +} t_eepromHeaderBlock; +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 BLOCK_ADDR[] = { 64, 4128 }; +static const uint16_t CONFIG_BLOCK_ADDR = EEPROM_CONFIG_BLOCK_ADDR; +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) { - static_assert((sizeof(*destConfigBlock) % EEPROM_WRITE_BLOCK_SIZE == 0), "config block has illegal size, must be dividable by 32"); +void eepromReadConfigBlock(t_configBlock *destConfigBlock) { +// 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++) { - for (uint8_t j = 0; j <= 127; j++) { - uint16_t addr = BLOCK_ADDR[i] + sizeof(emptyBlock) * j; - eepromWrite(addr, emptyBlock, sizeof(emptyBlock)); - eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY); - } - } - logMsg("eeI, storage blocks initialized"); - + eepromWrite(CONFIG_BLOCK_ADDR, emptyBlock, EEPROM_WRITE_BLOCK_SIZE); + eepromActiveDelay(EEPROM_AFTER_WRITE_DELAY); + logMsg("eeI, config block 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));