EEPROM_library_ported_Partition_table_updated (#535)

* EEPROM_library_ported_Partition_table_updated

* Cleanup & formal corrections

* Make formatting of file consistent.

Readability change, Concern about the SubType being 0x99.

* Code formatting cleanup

* Code formatting cleanup

* Code formatting cleanup

* Remove commented out code

* Restore dropped bracket

* Update EEPROM.cpp

* Format Corrections

* deletedExample

* Corrected example

* Deleted interrupts/nointerrupts

* Update EEPROM.cpp

libraries/EEPROM/EEPROM.cpp

@@ -0,0 +1,150 @@
+/*
+  EEPROM.cpp -ported by Paolo Becchi to Esp32  
+  Op
+  from esp8266 EEPROM emulation
+
+  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "Arduino.h"
+#include "EEPROM.h"
+
+#include <esp_log.h>
+
+static const char* TAG = "eeprom";
+
+EEPROMClass::EEPROMClass(uint32_t sector)
+: _sector(sector)
+, _data(0)
+, _size(0)
+, _dirty(false)
+{
+}
+
+EEPROMClass::EEPROMClass(void)
+	: _sector(0)// (((uint32_t)&_SPIFFS_end - 0x40200000) / SPI_FLASH_SEC_SIZE))
+, _data(0)
+, _size(0)
+, _dirty(false)
+{
+}
+
+bool EEPROMClass::begin(size_t size) {
+  if (size <= 0) {
+    return false;
+  }
+  if (size > SPI_FLASH_SEC_SIZE) {
+    size = SPI_FLASH_SEC_SIZE;
+  }
+  _mypart = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,ESP_PARTITION_SUBTYPE_ANY, EEPROM_FLASH_PARTITION_NAME);
+  if (_mypart == NULL) {
+    return false;
+  }
+  size = (size + 3) & (~3);
+
+  if (_data) {
+    delete[] _data;
+  }
+
+  _data = new uint8_t[size];
+  _size = size;	
+  bool ret = false;
+  if (esp_partition_read (_mypart,0, (void *) _data,_size)==ESP_OK) {
+    ret=true;
+  }
+  
+  return ret;
+}
+
+void EEPROMClass::end() {
+  if (!_size) {
+    return;
+  }
+
+  commit();
+  if (_data) {
+    delete[] _data;
+  }
+  _data = 0;
+  _size = 0;
+}
+
+uint8_t EEPROMClass::read(int address) {
+  if (address < 0 || (size_t)address >= _size) {
+    return 0;
+  }
+  if (!_data) {
+    return 0;
+  }
+
+  return _data[address];
+}
+
+void EEPROMClass::write(int address, uint8_t value) {
+  if (address < 0 || (size_t)address >= _size)
+    return;
+  if(!_data)
+    return;
+
+  // Optimise _dirty. Only flagged if data written is different.
+  uint8_t* pData = &_data[address];
+  if (*pData != value)
+  {
+    *pData = value;
+    _dirty = true;
+  }
+}
+
+bool EEPROMClass::commit() {
+  bool ret = false;
+  if (!_size)
+    return false;
+  if (!_dirty)
+    return true;
+  if (!_data)
+    return false;
+
+
+  if (esp_partition_erase_range(_mypart, 0, SPI_FLASH_SEC_SIZE) != ESP_OK)
+  {	  
+     log_e( "partition erase err.");
+  }
+  else
+  {
+     if (esp_partition_write(_mypart, 0, (void *)_data, _size) == ESP_ERR_INVALID_SIZE)
+     {
+	log_e( "error in Write");
+     }
+     else
+     {
+	_dirty = false;
+	ret = true;
+     }
+  }
+
+  return ret;
+}
+
+uint8_t * EEPROMClass::getDataPtr() {
+  _dirty = true;
+  return &_data[0];
+}
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_EEPROM)
+EEPROMClass EEPROM;
+#endif

libraries/EEPROM/EEPROM.h

@@ -0,0 +1,89 @@
+/* 
+   EEPROM.h -ported by Paolo Becchi to Esp32 
+
+   use a one sector flash partition defined in partition table
+  
+  from esp8266 EEPROM 
+
+  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+  This file is part of the esp8266 core for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef EEPROM_h
+#define EEPROM_h
+#ifndef EEPROM_FLASH_PARTITION_NAME
+ #define EEPROM_FLASH_PARTITION_NAME "eeprom"
+#endif
+extern "C" {
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <esp_partition.h>
+}
+
+//
+//   need to define a flash partition for EEPROM  with above name
+//
+//           eeprom , data , 0x99, start address, 0x1000
+//
+class EEPROMClass {
+public:
+  EEPROMClass(uint32_t sector);
+  EEPROMClass(void);
+
+  bool begin(size_t size);
+  uint8_t read(int address);
+  void write(int address, uint8_t val);
+  bool commit();
+  void end();
+
+  uint8_t * getDataPtr();
+
+  template<typename T> 
+  T &get(int address, T &t) {
+    if (address < 0 || address + sizeof(T) > _size)
+      return t;
+
+    memcpy((uint8_t*) &t, _data + address, sizeof(T));
+    return t;
+  }
+
+  template<typename T> 
+  const T &put(int address, const T &t) {
+    if (address < 0 || address + sizeof(T) > _size)
+      return t;
+
+    memcpy(_data + address, (const uint8_t*) &t, sizeof(T));
+    _dirty = true;
+    return t;
+  }
+
+protected:
+  uint32_t _sector;
+  uint8_t* _data;
+  size_t _size;
+  bool _dirty;
+  const esp_partition_t * _mypart;
+};
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_EEPROM)
+extern EEPROMClass EEPROM;
+#endif
+
+#endif
+

libraries/EEPROM/examples/eeprom_write/eeprom_write.ino

@@ -0,0 +1,63 @@
+/*
+   EEPROM Write
+
+   Stores random values into the EEPROM.
+   These values will stay in the EEPROM when the board is
+   turned off and may be retrieved later by another sketch.
+*/
+
+#include "EEPROM.h"
+
+// the current address in the EEPROM (i.e. which byte
+// we're going to write to next)
+int addr = 0;
+#define EEPROM_SIZE 64
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println("start...");
+  if (!EEPROM.begin(EEPROM_SIZE))
+  {
+    Serial.println("failed to initialise EEPROM"); delay(1000000);
+  }
+  Serial.println(" bytes read from Flash . Values are:");
+  for (int i = 0; i < EEPROM_SIZE; i++)
+  {
+    Serial.print(byte(EEPROM.read(i))); Serial.print(" ");
+  }
+  Serial.println();
+  Serial.println("writing random n. in memory");
+}
+
+void loop()
+{
+  // need to divide by 4 because analog inputs range from
+  // 0 to 1023 and each byte of the EEPROM can only hold a
+  // value from 0 to 255.
+  // int val = analogRead(10) / 4;
+  int val = byte(random(10020));
+  // write the value to the appropriate byte of the EEPROM.
+  // these values will remain there when the board is
+  // turned off.
+  EEPROM.write(addr, val);
+  Serial.print(val); Serial.print(" ");
+  // advance to the next address.  there are 512 bytes in
+  // the EEPROM, so go back to 0 when we hit 512.
+  // save all changes to the flash.
+  addr = addr + 1;
+  if (addr == EEPROM_SIZE)
+  {
+    Serial.println();
+    addr = 0;
+    EEPROM.commit();
+    Serial.print(EEPROM_SIZE);
+    Serial.println(" bytes written on Flash . Values are:");
+    for (int i = 0; i < EEPROM_SIZE; i++)
+    {
+      Serial.print(byte(EEPROM.read(i))); Serial.print(" ");
+    }
+    Serial.println(); Serial.println("----------------------------------");
+  }
+
+  delay(100);
+}

libraries/EEPROM/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+EEPROM	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

libraries/EEPROM/library.properties

@@ -0,0 +1,9 @@
+name=EEPROM
+version=1.0
+author=Ivan Grokhotkov
+maintainer=Paolo Becchi <pbecchi@aerobusiness.it>
+sentence=Enables reading and writing data to the permanent FLASH storage, up to 4kb.
+paragraph=
+category=Data Storage
+url=http://arduino.cc/en/Reference/EEPROM
+architectures=esp32

tools/partitions/default.csv

@@ -3,4 +3,5 @@ nvs,      data, nvs,     0x9000,  0x5000,
 otadata,  data, ota,     0xe000,  0x2000,
 app0,     app,  ota_0,   0x10000, 0x140000,
 app1,     app,  ota_1,   0x150000,0x140000,
-spiffs,   data, spiffs,  0x290000,0x170000,
+eeprom,   data, 0x99,    0x290000,0x1000,
+spiffs,   data, spiffs,  0x291000,0x169000