unfinished STM32FlashSettingsStorage

Author: Richard Unger

src/settings/README.md

@@ -17,8 +17,10 @@ Supported hardware:
 
 - [SAMD NVM](samd/) \
 Some SAMD chips have a built-in NVRAM flash, which can be written from user code.
-- [CAT24 I2C Flash EEPROMs](i2c/) \ :warning: UNFINISHED
+- [CAT24 I2C Flash EEPROMs](i2c/) :warning: UNFINISHED \
 Simple programmable memories with I2C interface. Memory space is quite limited, but enough for storing settings.
+- [STM32 Flash](stm32/) :warning: UNFINISHED \
+Store settings directly to STM32 on-board flash
 
 See Roadmap, below, for systems we may support in the future.
 

src/settings/stm32/README.md

@@ -0,0 +1,50 @@
+
+# STM32 Flash Settings Storage
+
+Store your settings directly to STM32 MCU's on-board flash memory.
+
+To store the settings, the flash memory has to be erased in whole pages. 
+
+The page size is typically 1kB or 2kB. You can check your page size in the datasheet for your MCU.
+
+The default settings storage location is the last page of the flash memory, meaning you have one page worth
+of space, maximum. If you need more space than this, you can provide the start address for the settings storage.
+
+Needless to say, you can only store settings to flash if that memory is not also needed by your program. So you have to have some reserve space in the flash of the MCU you're using. If memory is too tight, use a STM32 model with more flash.
+
+## Board setup
+
+When storing settings to the Flash of your STM32 MCU, you have to consider what happens when you reprogram the MCU. Unless you have taken steps in the board setup files to reserve the pages of flash used by the settings, they will generally be erased and/or overwritten when programming the MCU.
+
+To solve this, you can configure your board setup to reserve memory for settings, and not use that memory for program storage. Configuring STM32 board definitions for Arduino is out of scope for this readme, please find another reference.
+
+## Usage
+
+Using it is easy. Watch out if you have more than one page worth of settings to store, in which case you will need to configure the address to a different value from the default one.
+
+```c++
+// uses default address, which is 1 page below the maximum flash address, e.g. the last page of the flash
+STM32FlashSettingsStorage settings = STM32FlashSettingsStorage();
+
+// or use an address of your choice, in this case 10kB below the end of flash:
+#define SETTINGS_ADDRESS (FLASH_BASE + FLASH_SIZE - (1024*10))
+STM32FlashSettingsStorage settings = STM32FlashSettingsStorage(SETTINGS_ADDRESS);
+
+// use as normal in the setup method:
+void setup() {
+    SimpleFOCDebug::enable();
+
+    // link driver etc
+    // set default settings on motor, etc
+
+    settings.addMotor(&motor);
+    settings.init();
+    SettingsStatus loadStatus = settings.loadSettings();
+    driver.init();
+    motor.init();
+    motor.initFOC();
+    if (motor.motor_status == FOCMotorStatus::motor_ready && loadStatus != SFOC_SETTINGS_SUCCESS) {
+        settings.saveSettings();
+    }    
+}
+```

src/settings/stm32/STM32FlashSettingsStorage.cpp

@@ -0,0 +1,148 @@
+
+
+#include "./STM32FlashSettingsStorage.h"
+
+#if defined(_STM32_DEF_)
+
+#include "communication/SimpleFOCDebug.h"
+
+
+STM32FlashSettingsStorage::STM32FlashSettingsStorage(uint32_t address) {
+    _address = address;
+};
+
+STM32FlashSettingsStorage::~STM32FlashSettingsStorage(){};
+
+
+void STM32FlashSettingsStorage::init(){
+    if (!IS_FLASH_PROGRAM_ADDRESS(_address))
+        SimpleFOCDebug::println("SS: Invalid address");
+    SettingsStorage::init();
+    reset();
+};
+
+
+void STM32FlashSettingsStorage::reset() {
+    _currptr = (uint8_t*)_address;
+};
+
+
+void STM32FlashSettingsStorage::beforeLoad(){
+    reset();
+};
+
+void STM32FlashSettingsStorage::beforeSave(){
+    _writeptr = (uint8_t*)_address;
+    _buffed = 0;
+    _writeBuffer.l = 0;
+    _page = PAGE_OF(_writeptr);
+    if (HAL_FLASH_Unlock()!=HAL_OK)
+        SimpleFOCDebug::println("SS: Flash unlock err");
+    delay(50);
+    erasePage(_page);
+    delay(50);
+};
+
+
+void STM32FlashSettingsStorage::erasePage(uint32_t page) {
+    FLASH_EraseInitTypeDef eraseInit;    
+    eraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
+    eraseInit.Page = page;
+    eraseInit.Banks = _bank;
+    eraseInit.NbPages = 1;
+    uint32_t err;
+    SimpleFOCDebug::print("SS: erase page ");
+    SimpleFOCDebug::println((int)page);
+    if (HAL_FLASHEx_Erase(&eraseInit, &err) != HAL_OK) {
+        SimpleFOCDebug::println("SS: flash erase err");
+        HAL_FLASH_Lock();
+        return;
+    }
+};
+
+
+void STM32FlashSettingsStorage::flushBuffer() {
+    uint32_t page = PAGE_OF(_writeptr+7);
+    if (page != _page) {
+        erasePage(page);
+        _page = page;
+    }
+    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, (uint32_t)_writeptr, _writeBuffer.l)!=HAL_OK)
+        SimpleFOCDebug::println("SS: Flash write err");
+    _writeptr += 8;
+    _buffed = 0;
+    _writeBuffer.l = 0;
+};
+
+
+void STM32FlashSettingsStorage::afterSave(){
+    if (_buffed > 0)
+        flushBuffer();
+    HAL_FLASH_Lock();
+};
+
+
+
+int STM32FlashSettingsStorage::writeBytes(void* value, int numBytes) {
+    uint8_t* bytes = (uint8_t*)value;
+    for (int i=0;i<numBytes;i++) {
+        _writeBuffer.b[_buffed++] = bytes[i];
+        if (_buffed == 8)
+            flushBuffer();
+    }
+    return numBytes;
+}
+
+
+
+int STM32FlashSettingsStorage::readBytes(void* valueToSet, int numBytes) {
+    uint8_t* bytes = (uint8_t*)valueToSet;
+    for (int i=0;i<numBytes;i++) {
+        uint8_t val = *_currptr++;
+        bytes[i] = val;
+    }
+    return numBytes;
+}
+
+
+uint8_t STM32FlashSettingsStorage::readByte(uint8_t* valueToSet) {
+    uint8_t val;
+    uint8_t num = readBytes(&val, 1);
+    if (num==1)
+        *valueToSet = val;
+    return num;
+};
+
+uint8_t STM32FlashSettingsStorage::readFloat(float* valueToSet) {
+    float val;
+    uint8_t num = readBytes(&val, 4);
+    if (num==4)
+        *valueToSet = val;
+    return num;
+};
+
+uint8_t STM32FlashSettingsStorage::readInt(uint32_t* valueToSet) {
+    uint32_t val;
+    uint8_t num = readBytes(&val, 4);
+    if (num==4)
+        *valueToSet = val;
+    return num;
+};
+
+
+
+uint8_t STM32FlashSettingsStorage::writeByte(uint8_t value) {
+    return writeBytes(&value, 1);
+};
+
+
+uint8_t STM32FlashSettingsStorage::writeFloat(float value) {
+    return writeBytes(&value, 4);
+};
+
+
+uint8_t STM32FlashSettingsStorage::writeInt(uint32_t value) {
+    return writeBytes(&value, 4);
+};
+
+#endif

src/settings/stm32/STM32FlashSettingsStorage.h

@@ -0,0 +1,51 @@
+
+#pragma once
+
+#include "../SettingsStorage.h"
+
+#if defined(_STM32_DEF_)
+
+#define PAGE_OF(x) (((uint32_t)x - FLASH_BASE) / FLASH_PAGE_SIZE)
+
+
+class STM32FlashSettingsStorage : public SettingsStorage {
+public:
+    STM32FlashSettingsStorage(uint32_t address = FLASH_BASE + FLASH_SIZE - FLASH_PAGE_SIZE);
+    ~STM32FlashSettingsStorage();
+
+    void init() override;
+
+    uint32_t _bank = FLASH_BANK_1;
+    
+protected:
+    uint8_t readByte(uint8_t* valueToSet) override;
+    uint8_t readFloat(float* valueToSet) override;
+    uint8_t readInt(uint32_t* valueToSet) override;
+
+    uint8_t writeByte(uint8_t value) override;
+    uint8_t writeFloat(float value) override;
+    uint8_t writeInt(uint32_t value) override;
+
+    void beforeLoad() override;
+    void beforeSave() override;
+    void afterSave() override;
+
+    void flushBuffer();
+    void erasePage(uint32_t page);
+    void reset();
+    int readBytes(void* valueToSet, int numBytes);
+    int writeBytes(void* value, int numBytes);
+
+    uint32_t _address;
+    uint8_t* _currptr;
+    uint8_t* _writeptr;
+    uint8_t _buffed = 0;
+    uint32_t _page = 0;
+    union {
+        uint8_t b[8];
+        uint64_t l;
+    }  _writeBuffer;    // 64-bit buffer
+};
+
+
+#endif