Wrapper for externally-hold eeprom variables

Author: ggajoch

examples/all_targets/EEPROM/EEPROM.cpp

@@ -2,7 +2,8 @@
 
 using namespace hal;
 
-static EepromStorage<int> eepromVariable;
+int EEMEM eepromVariable_storage = 10;
+EepromWrapper<int> eepromVariable{eepromVariable_storage};
 
 int main() {
     Serial0.init(115200);

hal/periph/CMakeLists.txt

@@ -6,7 +6,6 @@ file(GLOB_RECURSE HAL_PERIPH_SOURCES
 
 add_library(${NAME} STATIC
     ${HAL_PERIPH_SOURCES}
-    MCU/eeprom.cpp
 )
 
 

hal/periph/MCU/eeprom.cpp

@@ -7,53 +7,61 @@
 
 namespace hal {
 
-namespace details {
-class AddressCounter {
- public:
-    static size_t getAndIncreaseBy(size_t c) {
-        auto now = counter;
-        counter += c;
-        return now;
-    }
-
- private:
-    static size_t counter;
-};
-
-}  // namespace details
-
+/*!
+ * EEPROM memory wrapper.
+ * For given type T and object in eeprom memory it will ease access to
+ * underlying type.
+ * @tparam T Type of underlying object
+ */
 template<typename T>
-class EepromStorage : details::AddressCounter {
+class EepromWrapper {
  public:
-    constexpr EepromStorage()
-        : eeprom_ptr(get_pointer_from_addess(getAndIncreaseBy(size))) {
+    /*!
+     * Constructor. Provide object defined with EEMEM attribute (placed in
+     * EEPROM memory).
+     * @param data_eeprom Object to wrap
+     */
+    explicit constexpr EepromWrapper(T& data_eeprom)
+        : eeprom_ptr{&data_eeprom} {
     }
 
+    /*!
+     * Read data from EEPROM.
+     * @return Data read from EEPROM.
+     */
     T read() const {
         T data;
-        this->read(gsl::make_span(&data, size));
+        read(gsl::make_span(&data, size));
         return data;
     }
 
+    /*!
+     * Read data from EEPROM. Allows reads without .read() method
+     * @return Data read from EEPROM.
+     */
     operator T() const {
         return this->read();
     }
 
+    /*!
+     * Write data to EEPROM object.
+     * @param data Data to write
+     */
     void write(const T& data) const {
-        this->write(gsl::make_span(&data, size));
+        write(gsl::make_span(&data, size));
     }
 
+    /*!
+     * Write data to EEPROM object.
+     * @param data Data to write
+     */
     void operator=(const T& data) const {
         this->write(data);
     }
 
  private:
-    void* get_pointer_from_addess(size_t address) {
-        return reinterpret_cast<void*>(address);
-    }
-
     void read(gsl::span<T> data_out) const {
-        eeprom_read_block(static_cast<void*>(data_out.begin()), eeprom_ptr, size);
+        eeprom_read_block(data_out.begin(), eeprom_ptr, size);
     }
     void write(gsl::span<const T> data_in) const {
         eeprom_write_block(data_in.begin(), eeprom_ptr, size);

hal/periph/MCU/eeprom.h

@@ -4,15 +4,35 @@
 
 using namespace hal;
 
-static EepromStorage<bool> var_bool;
-static EepromStorage<char> var_char;
-static EepromStorage<float> var_float;
-static EepromStorage<int16_t> var_int16;
-static EepromStorage<uint16_t> var_uint16;
-static EepromStorage<int32_t> var_int32;
+bool EEMEM eeprom_var_bool{true};
+EepromWrapper<bool> var_bool{eeprom_var_bool};
+
+char EEMEM eeprom_var_char{0x76};
+EepromWrapper<char> var_char{eeprom_var_char};
+
+float EEMEM eeprom_var_float{-123.48174};
+EepromWrapper<float> var_float{eeprom_var_float};
+
+int16_t EEMEM eeprom_var_int16{-4365};
+EepromWrapper<int16_t> var_int16{eeprom_var_int16};
+
+uint16_t EEMEM eeprom_var_uint16{64123};
+EepromWrapper<uint16_t> var_uint16{eeprom_var_uint16};
+
+int32_t EEMEM eeprom_var_int32{0x12FFFFFF};
+EepromWrapper<int32_t> var_int32{eeprom_var_int32};
 
 TEST_GROUP(eeprom);
 
+TEST(eeprom, default_values) {
+    TEST_ASSERT_EQUAL(true, var_bool);
+    TEST_ASSERT_EQUAL(0x76, var_char);
+    TEST_ASSERT_EQUAL_FLOAT(-123.48174, var_float);
+    TEST_ASSERT_EQUAL(-4365, var_int16);
+    TEST_ASSERT_EQUAL(64123, var_uint16);
+    TEST_ASSERT_EQUAL(0x12FFFFFF, var_int32);
+}
+
 TEST(eeprom, simple) {
     var_bool   = false;
     var_char   = 127;
@@ -42,3 +62,13 @@ TEST(eeprom, simple) {
     TEST_ASSERT_EQUAL(var_uint16, 0);
     TEST_ASSERT_EQUAL(var_int32, 458898752L);
 }
+
+TEST(eeprom, read_write) {
+    var_bool.write(false);
+
+    TEST_ASSERT_EQUAL(var_bool.read(), false);
+
+    var_bool.write(true);
+
+    TEST_ASSERT_EQUAL(var_bool.read(), true);
+}