Merge branch 'eeprom_rotate' into dev

README.md

@@ -4,9 +4,9 @@ ESPurna ("spark" in Catalan) is a custom firmware for ESP8285/ESP8266 based smar
 It uses the Arduino Core for ESP8266 framework and a number of 3rd party libraries.
 
 [![version](https://img.shields.io/badge/version-1.12.7a-brightgreen.svg)](CHANGELOG.md)
-[![branch](https://img.shields.io/badge/branch-justwifi2-orange.svg)](https://github.org/xoseperez/espurna/tree/justwifi2/)
-[![travis](https://travis-ci.org/xoseperez/espurna.svg?branch=justwifi2)](https://travis-ci.org/xoseperez/espurna)
-[![codacy](https://img.shields.io/codacy/grade/c9496e25cf07434cba786b462cb15f49/justwifi2.svg)](https://www.codacy.com/app/xoseperez/espurna/dashboard)
+[![branch](https://img.shields.io/badge/branch-dev-orange.svg)](https://github.org/xoseperez/espurna/tree/dev/)
+[![travis](https://travis-ci.org/xoseperez/espurna.svg?branch=dev)](https://travis-ci.org/xoseperez/espurna)
+[![codacy](https://img.shields.io/codacy/grade/c9496e25cf07434cba786b462cb15f49/dev.svg)](https://www.codacy.com/app/xoseperez/espurna/dashboard)
 [![license](https://img.shields.io/github/license/xoseperez/espurna.svg)](LICENSE)
 <br />
 [![donate](https://img.shields.io/badge/donate-PayPal-blue.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=xose%2eperez%40gmail%2ecom&lc=US&no_note=0&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHostedGuest)

code/esp8266.flash.1m0.ld → code/eagle.flash.1m0m1s.ld

@@ -1,4 +1,4 @@
-/* Flash Split for 1M chips, no SPIFFS */
+/* Flash Split for 1M chips */
 /* sketch 999KB */
 /* eeprom 20KB */
 
@@ -12,7 +12,7 @@ MEMORY
 
 PROVIDE ( _SPIFFS_start = 0x402FB000 );
 PROVIDE ( _SPIFFS_end = 0x402FB000 );
-PROVIDE ( _SPIFFS_page = 0 );
-PROVIDE ( _SPIFFS_block = 0 );
+PROVIDE ( _SPIFFS_page = 0x0 );
+PROVIDE ( _SPIFFS_block = 0x0 );
 
-INCLUDE "esp8266.flash.common.ld"
+INCLUDE "../ld/eagle.app.v6.common.ld"

code/eagle.flash.1m0m2s.ld

@@ -0,0 +1,19 @@
+/* Flash Split for 1M chips, no SPIFFS */
+/* sketch 995KB */
+/* eeprom 8KB */
+/* reserved 16KB */
+
+MEMORY
+{
+  dport0_0_seg :                        org = 0x3FF00000, len = 0x10
+  dram0_0_seg :                         org = 0x3FFE8000, len = 0x14000
+  iram1_0_seg :                         org = 0x40100000, len = 0x8000
+  irom0_0_seg :                         org = 0x40201010, len = 0xf8ff0
+}
+
+PROVIDE ( _SPIFFS_start = 0x402FA000 );
+PROVIDE ( _SPIFFS_end = 0x402FA000 );
+PROVIDE ( _SPIFFS_page = 0 );
+PROVIDE ( _SPIFFS_block = 0 );
+
+INCLUDE "../ld/eagle.app.v6.common.ld"

code/eagle.flash.4m1m4s.ld

@@ -0,0 +1,21 @@
+/* Flash Split for 4M chips */
+/* sketch 1019KB */
+/* empty/ota? 2048KB */
+/* spiffs 992KB */
+/* eeprom 16KB */
+/* reserved 16KB */
+
+MEMORY
+{
+  dport0_0_seg :                        org = 0x3FF00000, len = 0x10
+  dram0_0_seg :                         org = 0x3FFE8000, len = 0x14000
+  iram1_0_seg :                         org = 0x40100000, len = 0x8000
+  irom0_0_seg :                         org = 0x40201010, len = 0xfeff0
+}
+
+PROVIDE ( _SPIFFS_start = 0x40500000 );
+PROVIDE ( _SPIFFS_end = 0x405F8000 );
+PROVIDE ( _SPIFFS_page = 0x100 );
+PROVIDE ( _SPIFFS_block = 0x2000 );
+
+INCLUDE "../ld/eagle.app.v6.common.ld"

code/eagle.flash.4m3m4e.ld

@@ -0,0 +1,20 @@
+/* Flash Split for 4M chips */
+/* sketch 1019KB */
+/* spiffs 3040KB */
+/* eeprom 16KB */
+/* reserved 16KB */
+
+MEMORY
+{
+  dport0_0_seg :                        org = 0x3FF00000, len = 0x10
+  dram0_0_seg :                         org = 0x3FFE8000, len = 0x14000
+  iram1_0_seg :                         org = 0x40100000, len = 0x8000
+  irom0_0_seg :                         org = 0x40201010, len = 0xfeff0
+}
+
+PROVIDE ( _SPIFFS_start = 0x40300000 );
+PROVIDE ( _SPIFFS_end = 0x405F8000 );
+PROVIDE ( _SPIFFS_page = 0x100 );
+PROVIDE ( _SPIFFS_block = 0x2000 );
+
+INCLUDE "../ld/eagle.app.v6.common.ld"

code/eagle.flash.512k0m1s.ld

@@ -0,0 +1,18 @@
+/* Flash Split for 512K chips */
+/* sketch 487KB */
+/* eeprom 20KB */
+
+MEMORY
+{
+  dport0_0_seg :                        org = 0x3FF00000, len = 0x10
+  dram0_0_seg :                         org = 0x3FFE8000, len = 0x14000
+  iram1_0_seg :                         org = 0x40100000, len = 0x8000
+  irom0_0_seg :                         org = 0x40201010, len = 0x79ff0
+}
+
+PROVIDE ( _SPIFFS_start = 0x4027B000 );
+PROVIDE ( _SPIFFS_end = 0x4027B000 );
+PROVIDE ( _SPIFFS_page = 0x0 );
+PROVIDE ( _SPIFFS_block = 0x0 );
+
+INCLUDE "../ld/eagle.app.v6.common.ld"

code/espurna/config/general.h

@@ -142,12 +142,17 @@
 //------------------------------------------------------------------------------
 
 #define EEPROM_SIZE             4096            // EEPROM size in bytes
+//#define EEPROM_RORATE_SECTORS   2             // Number of sectors to use for EEPROM rotation
+                                                // If not defined the firmware will use a number based
+                                                // on the number of available sectors
+
 #define EEPROM_RELAY_STATUS     0               // Address for the relay status (1 byte)
 #define EEPROM_ENERGY_COUNT     1               // Address for the energy counter (4 bytes)
 #define EEPROM_CUSTOM_RESET     5               // Address for the reset reason (1 byte)
 #define EEPROM_CRASH_COUNTER    6               // Address for the crash counter (1 byte)
 #define EEPROM_MESSAGE_ID       7               // Address for the MQTT message id (4 bytes)
-#define EEPROM_DATA_END         11              // End of custom EEPROM data block
+#define EEPROM_ROTATE_DATA      11              // Reserved for the EEPROM_ROTATE library (3 bytes)
+#define EEPROM_DATA_END         14              // End of custom EEPROM data block
 
 //------------------------------------------------------------------------------
 // HEARTBEAT

code/espurna/config/prototypes.h

@@ -7,6 +7,12 @@ extern "C" {
     #include "user_interface.h"
 }
 
+// -----------------------------------------------------------------------------
+// EEPROM_ROTATE
+// -----------------------------------------------------------------------------
+#include <EEPROM_Rotate.h>
+EEPROM_Rotate EEPROMr;
+
 // -----------------------------------------------------------------------------
 // WebServer
 // -----------------------------------------------------------------------------
@@ -67,6 +73,7 @@ void settingsGetJson(JsonObject& data);
 bool settingsRestoreJson(JsonObject& data);
 void settingsRegisterCommand(const String& name, void (*call)(Embedis*));
 void settingsInject(void *data, size_t len);
+Stream & settingsSerial();
 
 // -----------------------------------------------------------------------------
 // I2C

code/espurna/debug.ino

@@ -10,7 +10,7 @@ Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
 
 #include <stdio.h>
 #include <stdarg.h>
-#include <EEPROM.h>
+#include <EEPROM_Rotate.h>
 
 extern "C" {
     #include "user_interface.h"
@@ -204,31 +204,31 @@ extern "C" void custom_crash_callback(struct rst_info * rst_info, uint32_t stack
 
     // write crash time to EEPROM
     uint32_t crash_time = millis();
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
 
     // write reset info to EEPROM
-    EEPROM.write(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_RESTART_REASON, rst_info->reason);
-    EEPROM.write(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCEPTION_CAUSE, rst_info->exccause);
+    EEPROMr.write(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_RESTART_REASON, rst_info->reason);
+    EEPROMr.write(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCEPTION_CAUSE, rst_info->exccause);
 
     // write epc1, epc2, epc3, excvaddr and depc to EEPROM
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC1, rst_info->epc1);
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC2, rst_info->epc2);
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC3, rst_info->epc3);
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCVADDR, rst_info->excvaddr);
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_DEPC, rst_info->depc);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC1, rst_info->epc1);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC2, rst_info->epc2);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC3, rst_info->epc3);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCVADDR, rst_info->excvaddr);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_DEPC, rst_info->depc);
 
     // write stack start and end address to EEPROM
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_START, stack_start);
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_END, stack_end);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_START, stack_start);
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_END, stack_end);
 
     // write stack trace to EEPROM
     int16_t current_address = SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_TRACE;
     for (uint32_t i = stack_start; i < stack_end; i++) {
         byte* byteValue = (byte*) i;
-        EEPROM.write(current_address++, *byteValue);
+        EEPROMr.write(current_address++, *byteValue);
     }
 
-    EEPROM.commit();
+    EEPROMr.commit();
 
 }
 
@@ -237,8 +237,8 @@ extern "C" void custom_crash_callback(struct rst_info * rst_info, uint32_t stack
  */
 void debugClearCrashInfo() {
     uint32_t crash_time = 0xFFFFFFFF;
-    EEPROM.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
-    EEPROM.commit();
+    EEPROMr.put(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
+    EEPROMr.commit();
 }
 
 /**
@@ -247,28 +247,28 @@ void debugClearCrashInfo() {
 void debugDumpCrashInfo() {
 
     uint32_t crash_time;
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_CRASH_TIME, crash_time);
     if ((crash_time == 0) || (crash_time == 0xFFFFFFFF)) {
         DEBUG_MSG_P(PSTR("[DEBUG] No crash info\n"));
         return;
     }
 
     DEBUG_MSG_P(PSTR("[DEBUG] Latest crash was at %lu ms after boot\n"), crash_time);
-    DEBUG_MSG_P(PSTR("[DEBUG] Reason of restart: %u\n"), EEPROM.read(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_RESTART_REASON));
-    DEBUG_MSG_P(PSTR("[DEBUG] Exception cause: %u\n"), EEPROM.read(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCEPTION_CAUSE));
+    DEBUG_MSG_P(PSTR("[DEBUG] Reason of restart: %u\n"), EEPROMr.read(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_RESTART_REASON));
+    DEBUG_MSG_P(PSTR("[DEBUG] Exception cause: %u\n"), EEPROMr.read(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCEPTION_CAUSE));
 
     uint32_t epc1, epc2, epc3, excvaddr, depc;
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC1, epc1);
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC2, epc2);
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC3, epc3);
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCVADDR, excvaddr);
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_DEPC, depc);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC1, epc1);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC2, epc2);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EPC3, epc3);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_EXCVADDR, excvaddr);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_DEPC, depc);
     DEBUG_MSG_P(PSTR("[DEBUG] epc1=0x%08x epc2=0x%08x epc3=0x%08x\n"), epc1, epc2, epc3);
     DEBUG_MSG_P(PSTR("[DEBUG] excvaddr=0x%08x depc=0x%08x\n"), excvaddr, depc);
 
     uint32_t stack_start, stack_end;
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_START, stack_start);
-    EEPROM.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_END, stack_end);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_START, stack_start);
+    EEPROMr.get(SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_END, stack_end);
     DEBUG_MSG_P(PSTR("[DEBUG] >>>stack>>>\n[DEBUG] "));
     int16_t current_address = SAVE_CRASH_EEPROM_OFFSET + SAVE_CRASH_STACK_TRACE;
     int16_t stack_len = stack_end - stack_start;
@@ -276,7 +276,7 @@ void debugDumpCrashInfo() {
     for (int16_t i = 0; i < stack_len; i += 0x10) {
         DEBUG_MSG_P(PSTR("%08x: "), stack_start + i);
         for (byte j = 0; j < 4; j++) {
-            EEPROM.get(current_address, stack_trace);
+            EEPROMr.get(current_address, stack_trace);
             DEBUG_MSG_P(PSTR("%08x "), stack_trace);
             current_address += 4;
         }

code/espurna/eeprom.ino

@@ -0,0 +1,82 @@
+/*
+
+EEPROM MODULE
+
+*/
+
+#include <EEPROM_Rotate.h>
+
+// -----------------------------------------------------------------------------
+
+bool eepromBackup() {
+    // Backup data to last sector if we are using more sectors than the
+    // reserved by the memory layout
+    if (EEPROMr.size() > EEPROMr.reserved()) {
+        DEBUG_MSG_P(PSTR("[EEPROM] Backing up data to last sector\n"));
+        return EEPROMr.backup();
+    }
+}
+
+String eepromSectors() {
+    String response;
+    for (uint32_t i = 0; i < EEPROMr.size(); i++) {
+        if (i > 0) response = response + String(", ");
+        response = response + String(EEPROMr.base() - i);
+    }
+    return response;
+}
+
+#if TERMINAL_SUPPORT
+
+void _eepromInitCommands() {
+
+    settingsRegisterCommand(F("EEPROM.DUMP"), [](Embedis* e) {
+        EEPROMr.dump(settingsSerial());
+        DEBUG_MSG_P(PSTR("\n+OK\n"));
+    });
+
+    settingsRegisterCommand(F("FLASH.DUMP"), [](Embedis* e) {
+        if (e->argc < 2) {
+            DEBUG_MSG_P(PSTR("-ERROR: Wrong arguments\n"));
+            return;
+        }
+        uint32_t sector = String(e->argv[1]).toInt();
+        uint32_t max = ESP.getFlashChipSize() / SPI_FLASH_SEC_SIZE;
+        if (sector >= max) {
+            DEBUG_MSG_P(PSTR("-ERROR: Sector out of range\n"));
+            return;
+        }
+        EEPROMr.dump(settingsSerial(), sector);
+        DEBUG_MSG_P(PSTR("\n+OK\n"));
+    });
+
+}
+
+#endif
+
+// -----------------------------------------------------------------------------
+
+void eepromSetup() {
+
+    #ifdef EEPROM_ROTATE_SECTORS
+        EEPROMr.size(EEPROM_ROTATE_SECTORS);
+    #else
+        // If the memory layout has more than one sector reserved use those,
+        // otherwise calculate pool size based on memory size.
+        if (EEPROMr.size() == 1) {
+            if (EEPROMr.last() > 1000) { // 4Mb boards
+                EEPROMr.size(4);
+            } else if (EEPROMr.last() > 250) { // 1Mb boards
+                EEPROMr.size(2);
+            }
+        }
+    #endif
+
+    EEPROMr.offset(EEPROM_ROTATE_DATA);
+    EEPROMr.begin(EEPROM_SIZE);
+
+    #if TERMINAL_SUPPORT
+        _eepromInitCommands();
+    #endif
+
+}

code/espurna/espurna.ino

@@ -47,7 +47,10 @@ void setup() {
         debugSetup();
     #endif
 
-    // Init EEPROM, Serial, SPIFFS and system check
+    // Init EEPROM
+    eepromSetup();
+    
+    // Init Serial, SPIFFS and system check
     systemSetup();
 
     // Init persistance and terminal features

code/espurna/mqtt.ino

@@ -8,7 +8,7 @@ Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
 
 #if MQTT_SUPPORT
 
-#include <EEPROM.h>
+#include <EEPROM_Rotate.h>
 #include <ESP8266WiFi.h>
 #include <ESP8266mDNS.h>
 #include <ArduinoJson.h>
@@ -265,7 +265,7 @@ unsigned long _mqttNextMessageId() {
     if (id == 0) {
 
         // read id from EEPROM and shift it
-        id = EEPROM.read(EEPROM_MESSAGE_ID);
+        id = EEPROMr.read(EEPROM_MESSAGE_ID);
         if (id == 0xFF) {
 
             // There was nothing in EEPROM,
@@ -274,9 +274,9 @@ unsigned long _mqttNextMessageId() {
 
         } else {
 
-            id = (id << 8) + EEPROM.read(EEPROM_MESSAGE_ID + 1);
-            id = (id << 8) + EEPROM.read(EEPROM_MESSAGE_ID + 2);
-            id = (id << 8) + EEPROM.read(EEPROM_MESSAGE_ID + 3);
+            id = (id << 8) + EEPROMr.read(EEPROM_MESSAGE_ID + 1);
+            id = (id << 8) + EEPROMr.read(EEPROM_MESSAGE_ID + 2);
+            id = (id << 8) + EEPROMr.read(EEPROM_MESSAGE_ID + 3);
 
             // Calculate next block and start from there
             id = MQTT_MESSAGE_ID_SHIFT * (1 + (id / MQTT_MESSAGE_ID_SHIFT));
@@ -287,11 +287,11 @@ unsigned long _mqttNextMessageId() {
 
     // Save to EEPROM every MQTT_MESSAGE_ID_SHIFT
     if (id % MQTT_MESSAGE_ID_SHIFT == 0) {
-        EEPROM.write(EEPROM_MESSAGE_ID + 0, (id >> 24) & 0xFF);
-        EEPROM.write(EEPROM_MESSAGE_ID + 1, (id >> 16) & 0xFF);
-        EEPROM.write(EEPROM_MESSAGE_ID + 2, (id >>  8) & 0xFF);
-        EEPROM.write(EEPROM_MESSAGE_ID + 3, (id >>  0) & 0xFF);
-        EEPROM.commit();
+        EEPROMr.write(EEPROM_MESSAGE_ID + 0, (id >> 24) & 0xFF);
+        EEPROMr.write(EEPROM_MESSAGE_ID + 1, (id >> 16) & 0xFF);
+        EEPROMr.write(EEPROM_MESSAGE_ID + 2, (id >>  8) & 0xFF);
+        EEPROMr.write(EEPROM_MESSAGE_ID + 3, (id >>  0) & 0xFF);
+        EEPROMr.commit();
     }
 
     id++;

code/espurna/ota.ino

@@ -133,6 +133,9 @@ void _otaFrom(const char * host, unsigned int port, const char * url) {
             }
         #endif
 
+        // Backup EEPROM data to last sector
+        eepromBackup();
+
         DEBUG_MSG_P(PSTR("[OTA] Downloading %s\n"), _ota_url);
         char buffer[strlen_P(OTA_REQUEST_TEMPLATE) + strlen(_ota_url) + strlen(_ota_host)];
         snprintf_P(buffer, sizeof(buffer), OTA_REQUEST_TEMPLATE, _ota_url, _ota_host);
@@ -140,7 +143,6 @@ void _otaFrom(const char * host, unsigned int port, const char * url) {
 
     }, NULL);
 
-
     #if ASYNC_TCP_SSL_ENABLED
         bool connected = _ota_client->connect(host, port, 443 == port);
     #else
@@ -214,10 +216,16 @@ void otaSetup() {
     // -------------------------------------------------------------------------
 
     ArduinoOTA.onStart([]() {
+
+        // Backup EEPROM data to last sector
+        eepromBackup();
+
         DEBUG_MSG_P(PSTR("[OTA] Start\n"));
+
         #if WEB_SUPPORT
             wsSend_P(PSTR("{\"message\": 2}"));
         #endif
+
     });
 
     ArduinoOTA.onEnd([]() {

code/espurna/relay.ino

@@ -6,7 +6,7 @@ Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
 
 */
 
-#include <EEPROM.h>
+#include <EEPROM_Rotate.h>
 #include <Ticker.h>
 #include <ArduinoJson.h>
 #include <vector>
@@ -369,9 +369,9 @@ void relaySave() {
         if (relayStatus(i)) mask += bit;
         bit += bit;
     }
-    EEPROM.write(EEPROM_RELAY_STATUS, mask);
+    EEPROMr.write(EEPROM_RELAY_STATUS, mask);
     DEBUG_MSG_P(PSTR("[RELAY] Saving mask: %d\n"), mask);
-    EEPROM.commit();
+    EEPROMr.commit();
 }
 
 void relayToggle(unsigned char id, bool report, bool group_report) {
@@ -449,7 +449,7 @@ void _relayBoot() {
     bool trigger_save = false;
 
     // Get last statuses from EEPROM
-    unsigned char mask = EEPROM.read(EEPROM_RELAY_STATUS);
+    unsigned char mask = EEPROMr.read(EEPROM_RELAY_STATUS);
     DEBUG_MSG_P(PSTR("[RELAY] Retrieving mask: %d\n"), mask);
 
     // Walk the relays
@@ -487,8 +487,8 @@ void _relayBoot() {
 
     // Save if there is any relay in the RELAY_BOOT_TOGGLE mode
     if (trigger_save) {
-        EEPROM.write(EEPROM_RELAY_STATUS, mask);
-        EEPROM.commit();
+        EEPROMr.write(EEPROM_RELAY_STATUS, mask);
+        EEPROMr.commit();
     }
 
     _relayRecursive = false;
@@ -811,6 +811,7 @@ void _relayInitCommands() {
     settingsRegisterCommand(F("RELAY"), [](Embedis* e) {
         if (e->argc < 2) {
             DEBUG_MSG_P(PSTR("-ERROR: Wrong arguments\n"));
+            return;
         }
         int id = String(e->argv[1]).toInt();
         if (e->argc > 2) {

code/espurna/settings.ino

@@ -6,7 +6,7 @@ Copyright (C) 2016-2018 by Xose Pérez <xose dot perez at gmail dot com>
 
 */
 
-#include <EEPROM.h>
+#include <EEPROM_Rotate.h>
 #include <vector>
 #include "libs/EmbedisWrap.h"
 #include <Stream.h>
@@ -30,7 +30,7 @@ bool _settings_save = false;
 
 unsigned long settingsSize() {
     unsigned pos = SPI_FLASH_SEC_SIZE - 1;
-    while (size_t len = EEPROM.read(pos)) {
+    while (size_t len = EEPROMr.read(pos)) {
         pos = pos - len - 2;
     }
     return SPI_FLASH_SEC_SIZE - pos;
@@ -41,9 +41,9 @@ unsigned long settingsSize() {
 unsigned int _settingsKeyCount() {
     unsigned count = 0;
     unsigned pos = SPI_FLASH_SEC_SIZE - 1;
-    while (size_t len = EEPROM.read(pos)) {
+    while (size_t len = EEPROMr.read(pos)) {
         pos = pos - len - 2;
-        len = EEPROM.read(pos);
+        len = EEPROMr.read(pos);
         pos = pos - len - 2;
         count ++;
     }
@@ -56,17 +56,17 @@ String _settingsKeyName(unsigned int index) {
 
     unsigned count = 0;
     unsigned pos = SPI_FLASH_SEC_SIZE - 1;
-    while (size_t len = EEPROM.read(pos)) {
+    while (size_t len = EEPROMr.read(pos)) {
         pos = pos - len - 2;
         if (count == index) {
             s.reserve(len);
             for (unsigned char i = 0 ; i < len; i++) {
-                s += (char) EEPROM.read(pos + i + 1);
+                s += (char) EEPROMr.read(pos + i + 1);
             }
             break;
         }
         count++;
-        len = EEPROM.read(pos);
+        len = EEPROMr.read(pos);
         pos = pos - len - 2;
     }
 
@@ -156,27 +156,16 @@ void _settingsKeysCommand() {
 
     unsigned long freeEEPROM = SPI_FLASH_SEC_SIZE - settingsSize();
     DEBUG_MSG_P(PSTR("Number of keys: %d\n"), keys.size());
+    DEBUG_MSG_P(PSTR("Current EEPROM sector: %u\n"), EEPROMr.current());
     DEBUG_MSG_P(PSTR("Free EEPROM: %d bytes (%d%%)\n"), freeEEPROM, 100 * freeEEPROM / SPI_FLASH_SEC_SIZE);
 
 }
 
 void _settingsFactoryResetCommand() {
     for (unsigned int i = 0; i < SPI_FLASH_SEC_SIZE; i++) {
-        EEPROM.write(i, 0xFF);
-    }
-    EEPROM.commit();
-}
-
-void _settingsDumpCommand(bool ascii) {
-    for (unsigned int i = 0; i < SPI_FLASH_SEC_SIZE; i++) {
-        if (i % 16 == 0) DEBUG_MSG_P(PSTR("\n[%04X] "), i);
-        byte c = EEPROM.read(i);
-        if (ascii && 32 <= c && c <= 126) {
-            DEBUG_MSG_P(PSTR(" %c "), c);
-        } else {
-            DEBUG_MSG_P(PSTR("%02X "), c);
-        }
+        EEPROMr.write(i, 0xFF);
     }
+    EEPROMr.commit();
 }
 
 void _settingsInitCommands() {
@@ -194,13 +183,6 @@ void _settingsInitCommands() {
         DEBUG_MSG_P(PSTR("+OK\n"));
     });
 
-    settingsRegisterCommand(F("EEPROM.DUMP"), [](Embedis* e) {
-        bool ascii = false;
-        if (e->argc == 2) ascii = String(e->argv[1]).toInt() == 1;
-        _settingsDumpCommand(ascii);
-        DEBUG_MSG_P(PSTR("\n+OK\n"));
-    });
-
     settingsRegisterCommand(F("ERASE.CONFIG"), [](Embedis* e) {
         DEBUG_MSG_P(PSTR("+OK\n"));
         resetReason(CUSTOM_RESET_TERMINAL);
@@ -282,7 +264,7 @@ void _settingsInitCommands() {
     });
 
     settingsRegisterCommand(F("RESET.SAFE"), [](Embedis* e) {
-        EEPROM.write(EEPROM_CRASH_COUNTER, SYSTEM_CHECK_MAX);
+        EEPROMr.write(EEPROM_CRASH_COUNTER, SYSTEM_CHECK_MAX);
         DEBUG_MSG_P(PSTR("+OK\n"));
         deferredReset(100, CUSTOM_RESET_TERMINAL);
     });
@@ -360,6 +342,10 @@ void settingsInject(void *data, size_t len) {
     _serial.inject((char *) data, len);
 }
 
+Stream & settingsSerial() {
+    return (Stream &) _serial;
+}
+
 size_t settingsMaxSize() {
     size_t size = EEPROM_SIZE;
     if (size > SPI_FLASH_SEC_SIZE) size = SPI_FLASH_SEC_SIZE;
@@ -373,7 +359,7 @@ bool settingsRestoreJson(JsonObject& data) {
     if (strcmp(app, APP_NAME) != 0) return false;
 
     for (unsigned int i = EEPROM_DATA_END; i < SPI_FLASH_SEC_SIZE; i++) {
-        EEPROM.write(i, 0xFF);
+        EEPROMr.write(i, 0xFF);
     }
 
     for (auto element : data) {
@@ -412,7 +398,7 @@ void settingsRegisterCommand(const String& name, void (*call)(Embedis*)) {
 
 void settingsSetup() {
 
-    EEPROM.begin(SPI_FLASH_SEC_SIZE);
+    EEPROMr.begin(SPI_FLASH_SEC_SIZE);
 
     _serial.callback([](uint8_t ch) {
         #if TELNET_SUPPORT
@@ -425,8 +411,8 @@ void settingsSetup() {
 
     Embedis::dictionary( F("EEPROM"),
         SPI_FLASH_SEC_SIZE,
-        [](size_t pos) -> char { return EEPROM.read(pos); },
-        [](size_t pos, char value) { EEPROM.write(pos, value); },
+        [](size_t pos) -> char { return EEPROMr.read(pos); },
+        [](size_t pos, char value) { EEPROMr.write(pos, value); },
         #if SETTINGS_AUTOSAVE
             []() { _settings_save = true; }
         #else
@@ -450,7 +436,7 @@ void settingsSetup() {
 void settingsLoop() {
 
     if (_settings_save) {
-        EEPROM.commit();
+        EEPROMr.commit();
         _settings_save = false;
     }
 

code/espurna/system.ino

@@ -6,7 +6,7 @@ Copyright (C) 2018 by Xose Pérez <xose dot perez at gmail dot com>
 
 */
 
-#include <EEPROM.h>
+#include <EEPROM_Rotate.h>
 
 // -----------------------------------------------------------------------------
 
@@ -30,7 +30,7 @@ unsigned short int _load_average = 100;
 bool _systemStable = true;
 
 void systemCheck(bool stable) {
-    unsigned char value = EEPROM.read(EEPROM_CRASH_COUNTER);
+    unsigned char value = EEPROMr.read(EEPROM_CRASH_COUNTER);
     if (stable) {
         value = 0;
         DEBUG_MSG_P(PSTR("[MAIN] System OK\n"));
@@ -41,8 +41,8 @@ void systemCheck(bool stable) {
             DEBUG_MSG_P(PSTR("[MAIN] System UNSTABLE\n"));
         }
     }
-    EEPROM.write(EEPROM_CRASH_COUNTER, value);
-    EEPROM.commit();
+    EEPROMr.write(EEPROM_CRASH_COUNTER, value);
+    EEPROMr.commit();
 }
 
 bool systemCheck() {
@@ -148,8 +148,6 @@ void _systemSetupSpecificHardware() {
 
 void systemSetup() {
 
-    EEPROM.begin(EEPROM_SIZE);
-
     #if SPIFFS_SUPPORT
         SPIFFS.begin();
     #endif

code/espurna/utils.ino

@@ -211,10 +211,42 @@ void heartbeat() {
 
 #endif /// HEARTBEAT_ENABLED
 
-unsigned int sectors(size_t size) {
+// -----------------------------------------------------------------------------
+// INFO
+// -----------------------------------------------------------------------------
+
+extern "C" uint32_t _SPIFFS_start;
+extern "C" uint32_t _SPIFFS_end;
+
+unsigned int info_bytes2sectors(size_t size) {
     return (int) (size + SPI_FLASH_SEC_SIZE - 1) / SPI_FLASH_SEC_SIZE;
 }
 
+unsigned long info_ota_space() {
+    return (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+}
+
+unsigned long info_filesystem_space() {
+    return ((uint32_t)&_SPIFFS_end - (uint32_t)&_SPIFFS_start);
+}
+
+unsigned long info_eeprom_space() {
+    return EEPROMr.reserved() * SPI_FLASH_SEC_SIZE;
+}
+
+void _info_print_memory_layout_line(const char * name, unsigned long bytes, bool reset) {
+    static unsigned long index = 0;
+    if (reset) index = 0;
+    if (0 == bytes) return;
+    unsigned int _sectors = info_bytes2sectors(bytes);
+    DEBUG_MSG_P(PSTR("[INIT] %-20s: %8lu bytes / %4d sectors (%4d to %4d)\n"), name, bytes, _sectors, index, index + _sectors - 1);
+    index += _sectors;
+}
+
+void _info_print_memory_layout_line(const char * name, unsigned long bytes) {
+    _info_print_memory_layout_line(name, bytes, false);
+}
+
 void info() {
 
     DEBUG_MSG_P(PSTR("\n\n"));
@@ -235,13 +267,18 @@ void info() {
     DEBUG_MSG_P(PSTR("[INIT] Flash speed: %u Hz\n"), ESP.getFlashChipSpeed());
     DEBUG_MSG_P(PSTR("[INIT] Flash mode: %s\n"), mode == FM_QIO ? "QIO" : mode == FM_QOUT ? "QOUT" : mode == FM_DIO ? "DIO" : mode == FM_DOUT ? "DOUT" : "UNKNOWN");
     DEBUG_MSG_P(PSTR("\n"));
-    DEBUG_MSG_P(PSTR("[INIT] Flash sector size: %8u bytes\n"), SPI_FLASH_SEC_SIZE);
-    DEBUG_MSG_P(PSTR("[INIT] Flash size (CHIP): %8u bytes\n"), ESP.getFlashChipRealSize());
-    DEBUG_MSG_P(PSTR("[INIT] Flash size (SDK):  %8u bytes / %4d sectors\n"), ESP.getFlashChipSize(), sectors(ESP.getFlashChipSize()));
-    DEBUG_MSG_P(PSTR("[INIT] Firmware size:     %8u bytes / %4d sectors\n"), ESP.getSketchSize(), sectors(ESP.getSketchSize()));
-    DEBUG_MSG_P(PSTR("[INIT] Max OTA size:      %8u bytes / %4d sectors\n"), maxSketchSpace(), sectors(maxSketchSpace()));
-    DEBUG_MSG_P(PSTR("[INIT] EEPROM size:       %8u bytes / %4d sectors\n"), settingsMaxSize(), sectors(settingsMaxSize()));
-    DEBUG_MSG_P(PSTR("[INIT] Empty space:       %8u bytes /    4 sectors\n"), 4 * SPI_FLASH_SEC_SIZE);
+
+    _info_print_memory_layout_line("Flash size (CHIP)", ESP.getFlashChipRealSize(), true);
+    _info_print_memory_layout_line("Flash size (SDK)", ESP.getFlashChipSize(), true);
+    _info_print_memory_layout_line("Reserved", 1 * SPI_FLASH_SEC_SIZE, true);
+    _info_print_memory_layout_line("Firmware size", ESP.getSketchSize());
+    _info_print_memory_layout_line("Max OTA size", info_ota_space());
+    _info_print_memory_layout_line("SPIFFS size", info_filesystem_space());
+    _info_print_memory_layout_line("EEPROM size", info_eeprom_space());
+    _info_print_memory_layout_line("Reserved", 4 * SPI_FLASH_SEC_SIZE);
+    DEBUG_MSG_P(PSTR("\n"));
+
+    DEBUG_MSG_P(PSTR("[INIT] EEPROM sectors: %s\n"), (char *) eepromSectors().c_str());
     DEBUG_MSG_P(PSTR("\n"));
 
     // -------------------------------------------------------------------------
@@ -508,7 +545,7 @@ bool sslFingerPrintChar(const char * fingerprint, char * destination) {
 unsigned char resetReason() {
     static unsigned char status = 255;
     if (status == 255) {
-        status = EEPROM.read(EEPROM_CUSTOM_RESET);
+        status = EEPROMr.read(EEPROM_CUSTOM_RESET);
         if (status > 0) resetReason(0);
         if (status > CUSTOM_RESET_MAX) status = 0;
     }
@@ -516,8 +553,8 @@ unsigned char resetReason() {
 }
 
 void resetReason(unsigned char reason) {
-    EEPROM.write(EEPROM_CUSTOM_RESET, reason);
-    EEPROM.commit();
+    EEPROMr.write(EEPROM_CUSTOM_RESET, reason);
+    EEPROMr.commit();
 }
 
 void reset(unsigned char reason) {

code/espurna/web.ino

@@ -231,7 +231,12 @@ void _onUpgrade(AsyncWebServerRequest *request) {
 }
 
 void _onUpgradeData(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
+
     if (!index) {
+
+        // Backup EEPROM data to last sector
+        eepromBackup();
+
         DEBUG_MSG_P(PSTR("[UPGRADE] Start: %s\n"), filename.c_str());
         Update.runAsync(true);
         if (!Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000)) {
@@ -239,7 +244,9 @@ void _onUpgradeData(AsyncWebServerRequest *request, String filename, size_t inde
                 Update.printError(DEBUG_PORT);
             #endif
         }
+
     }
+
     if (!Update.hasError()) {
         if (Update.write(data, len) != len) {
             #ifdef DEBUG_PORT
@@ -247,6 +254,7 @@ void _onUpgradeData(AsyncWebServerRequest *request, String filename, size_t inde
             #endif
         }
     }
+
     if (final) {
         if (Update.end(true)){
             DEBUG_MSG_P(PSTR("[UPGRADE] Success:  %u bytes\n"), index + len);