Diff: NVProperty.cpp

Revision:

1:3a8297ad8cd9

Child:

4:eb6850e3bc21

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/NVProperty.cpp	Thu Jan 24 14:28:11 2019 +0100
@@ -0,0 +1,355 @@
+/*
+ * This is an unpublished work copyright
+ * (c) 2019 Helmut Tschemernjak
+ * 30826 Garbsen (Hannover) Germany
+ *
+ *
+ * Use is granted to registered RadioShuttle licensees only.
+ * Licensees must own a valid serial number and product code.
+ * Details see: www.radioshuttle.de
+ */
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#elif __MBED__
+#include <mbed.h>
+#else
+#error "Unkown operating system"
+#endif
+
+
+#include <NVPropertyProviderInterface.h>
+#include <NVProperty_SRAM.h>
+#ifdef ARDUINO_ARCH_ESP32
+  #include <NVProperty_ESP32NVS.h>
+  #include <NVProperty_ESP32efuse.h>
+#elif defined(ARDUINO_SAMD_ZERO) || defined(ARDUINO_ARCH_SAMD)
+  #include <NVProperty_D21Flash.h>
+#elif defined(__MBED__) && defined(TARGET_STM32L4)
+  #include <mbed.h>
+  #include <NVProperty_L4OTP.h>
+  #include <NVProperty_L4Flash.h>
+#else
+#error "Unkown implementation"
+#endif
+#include <NVProperty.h>
+
+
+NVProperty::NVProperty(int propSizekB, bool erase)
+{
+    _flash = NULL;
+    _otp = NULL;
+    _ram = new NVProperty_SRAM();
+    
+#ifdef ARDUINO_ARCH_ESP32
+    _flash = new NVProperty_ESP32NVS();
+#elif defined(ARDUINO_SAMD_ZERO) || defined(ARDUINO_ARCH_SAMD)
+    _flash = new NVProperty_D21Flash(propSizekB, erase);
+#elif TARGET_STM32L4
+	// TODO _flash = new NVProperty_L4Flash(propSizekB, erase);
+#else
+ #error "unkown platform"
+#endif
+
+#ifdef ARDUINO_ARCH_ESP32
+    _otp = new NVProperty_ESP32efuse();
+#elif TARGET_STM32L4
+    _otp = new NVProperty_L4OTP();
+#endif
+    _allowWrite = false;
+    _didOpen = false;
+}
+
+NVProperty::~NVProperty()
+{
+    if (_ram) {
+    	delete _ram;
+	}
+	if (_flash)
+        delete _flash;
+    if (_otp)
+        delete _otp;
+}
+
+
+int
+NVProperty::GetProperty(int key, int defaultValue)
+{
+    int res;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+    
+    if (_ram) {
+        res = _ram->GetProperty(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    if (_flash) {
+        res = _flash->GetProperty(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    if (_otp) {
+        res = _otp->GetProperty(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    return defaultValue;
+}
+
+
+int64_t
+NVProperty::GetProperty64(int key, int64_t defaultValue)
+{
+    int64_t res;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (_ram) {
+        res = _ram->GetProperty64(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    if (_flash) {
+        res = _flash->GetProperty64(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    if (_otp) {
+        res = _otp->GetProperty64(key);
+        if (res != NVP_ENOENT)
+            return res;
+    }
+    return defaultValue;
+}
+
+const char *
+NVProperty::GetProperty(int key, const char *defaultValue)
+{
+    const char *res;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (_ram) {
+        res = _ram->GetPropertyStr(key);
+        if (res != NULL)
+            return res;
+    }
+    if (_flash) {
+        res = _flash->GetPropertyStr(key);
+        if (res != NULL)
+            return res;
+    }
+    if (_otp) {
+        res = _otp->GetPropertyStr(key);
+        if (res != NULL)
+            return res;
+    }
+    if (res != NULL)
+        return res;
+    
+    return defaultValue;
+}
+
+int
+NVProperty::GetProperty(int key, void *buffer, int *size)
+{
+    int res;
+    int maxsize = *size;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (_ram) {
+        res = _ram->GetPropertyBlob(key, buffer, &maxsize);
+        if (res == NVP_OK)
+            return res;
+    }
+    if (_flash) {
+        res = _flash->GetPropertyBlob(key, buffer, &maxsize);
+        if (res == NVP_OK)
+            return res;
+    }
+    if (_otp) {
+        res = _otp->GetPropertyBlob(key, buffer, &maxsize);
+        if (res == NVP_OK)
+            return res;
+    }
+ 
+    return NVP_ENOENT;
+}
+
+
+int
+NVProperty::SetProperty(int key, NVPType ptype, int64_t value, NVPStore store)
+{
+    int res = NVP_OK;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (!_allowWrite)
+        return NVP_NO_PERM;
+    
+    if (store == S_RAM && _ram) {
+        	res = _ram->SetProperty(key, value, ptype);
+    } else if (store == S_FLASH && _flash) {
+            res = _flash->SetProperty(key, value, ptype);
+    } else if (store == S_OTP && _otp) {
+            res = _otp->SetProperty(key, value, ptype);
+    } else {
+        return NVP_NO_STORE;
+    }
+    return res;
+}
+
+
+int
+NVProperty::SetProperty(int key, NVPType ptype, const char *value, NVPStore store)
+{
+    int res = NVP_OK;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (!_allowWrite)
+        return NVP_NO_PERM;
+
+    if (store == S_RAM && _ram) {
+        res = _ram->SetPropertyStr(key, value, ptype);
+    } else if (store == S_FLASH && _flash) {
+        res = _flash->SetPropertyStr(key, value, ptype);
+    } else if (store == S_OTP && _otp) {
+        res = _otp->SetPropertyStr(key, value, ptype);
+    } else {
+        return NVP_NO_STORE;
+    }
+    
+    return res;
+}
+
+// NVProperty_SRAM::SetPropertyBlob(int key, const void *blob, int size, int type)
+
+
+int
+NVProperty::SetProperty(int key, NVPType ptype,  const void *blob, int length, NVPStore store)
+{
+    int res = NVP_OK;
+
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (!_allowWrite) {
+        return NVP_NO_PERM;
+	}
+ 	
+  	if (store == S_RAM && _ram) {
+        res = _ram->SetPropertyBlob(key, blob, length, ptype);
+    } else if (store == S_FLASH && _flash) {
+        res = _flash->SetPropertyBlob(key, blob, length, ptype);
+    } else if (store == S_OTP && _otp) {
+        res = _otp->SetPropertyBlob(key, blob, length, ptype);
+    } else {
+        return NVP_NO_STORE;
+    }
+
+    return res;
+}
+
+int
+NVProperty::EraseProperty(int key, NVPStore store)
+{
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    int res = NVP_OK;
+    
+    if (!_allowWrite)
+        return NVP_NO_PERM;
+
+    if (store == S_RAM && _ram) {
+        res = _ram->EraseProperty(key);
+    } else if (store == S_FLASH && _flash) {
+        res = _flash->EraseProperty(key);
+    } else if (store == S_OTP && _otp) {
+        res = _otp->EraseProperty(key);
+    } else {
+        return NVP_NO_STORE;
+    }
+    
+    return res;
+}
+
+int
+NVProperty::ReorgProperties(NVPStore store)
+{
+    int res = NVP_OK;
+    
+    if (!_didOpen)
+        OpenPropertyStore();
+
+    if (!_allowWrite)
+        return NVP_NO_PERM;
+
+    if (store == S_RAM && _ram) {
+        res = _ram->ReorgProperties();
+    } else if (store == S_FLASH && _flash) {
+        res = _flash->ReorgProperties();
+    } else if (store == S_OTP && _otp) {
+        res = _otp->ReorgProperties();
+    } else {
+        return NVP_NO_STORE;
+    }
+    
+    return res;
+}
+
+int
+NVProperty::OpenPropertyStore(bool forWrite)
+{
+    int res = NVP_OK;
+
+    if (_didOpen) {
+        if (_ram)
+            _ram->ClosePropertyStore();
+        if (_flash)
+            _flash->ClosePropertyStore();
+        if (_otp)
+            _otp->ClosePropertyStore();
+    }
+    
+    if (_ram)
+        _ram->OpenPropertyStore(forWrite);
+    if (_flash)
+        res = _flash->OpenPropertyStore(forWrite);
+    if (_otp)
+        _otp->OpenPropertyStore(forWrite);
+    _didOpen = true;
+    if(forWrite)
+        _allowWrite = true;
+    
+
+    return res;
+}
+
+int
+NVProperty::ClosePropertyStore(bool flush)
+{
+    int res = NVP_OK;
+
+    if (_didOpen)
+        return NVP_NO_PERM;
+
+    if (_ram)
+        _ram->ClosePropertyStore(flush);
+    if (_flash)
+        res = _flash->ClosePropertyStore(flush);
+    if (_otp)
+        _otp->ClosePropertyStore(flush);
+    return res;
+}
+
+