arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-04-21 10:26:06 +03:00
Code

EEPROM: fix incorrect start address, support multiple instances

Browse Source 
related to #279, #240
This commit is contained in:
Ivan Grokhotkov 2015-05-21 10:22:45 +03:00
parent 6e14666d2f
commit b1f2fdb9cc
3 changed files with 104 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
libraries/EEPROM/EEPROM.cpp
View File

@ -28,35 +28,35 @@
#include "os_type.h" #include "os_type.h"
#include "osapi.h" #include "osapi.h"
#include "spi_flash.h" #include "spi_flash.h"
extern uint32_t _SPIFFS_end;
} }
#define CONFIG_START_SECTOR (((uint32_t)_SPIFFS_end - 0x40200000) / 4096) EEPROMClass::EEPROMClass(uint32_t sector)
#define CONFIG_SECTOR (CONFIG_START_SECTOR + 0) : _sector(sector)
#define CONFIG_ADDR (SPI_FLASH_SEC_SIZE * CONFIG_SECTOR) , _data(0)
, _size(0)
EEPROMClass::EEPROMClass() , _dirty(false)
: _data(0), _size(0), _dirty(false)
{ {
} }
void EEPROMClass::begin(size_t size) void EEPROMClass::begin(size_t size) {
{
if (size <= 0) if (size <= 0)
return; return;
if (size > SPI_FLASH_SEC_SIZE) if (size > SPI_FLASH_SEC_SIZE)
size = SPI_FLASH_SEC_SIZE; size = SPI_FLASH_SEC_SIZE;
if (_data) {
delete[] _data;
}
_data = new uint8_t[size]; _data = new uint8_t[size];
_size = size; _size = size;
noInterrupts(); noInterrupts();
spi_flash_read(CONFIG_ADDR, reinterpret_cast<uint32_t*>(_data), _size); spi_flash_read(_sector * SPI_FLASH_SEC_SIZE, reinterpret_cast<uint32_t*>(_data), _size);
interrupts(); interrupts();
} }
void EEPROMClass::end() void EEPROMClass::end() {
{
if (!_size) if (!_size)
return; return;
@ -69,8 +69,7 @@ void EEPROMClass::end()
} }
uint8_t EEPROMClass::read(int address) uint8_t EEPROMClass::read(int address) {
{
if (address < 0 || (size_t)address >= _size) if (address < 0 || (size_t)address >= _size)
return 0; return 0;
if(!_data) if(!_data)
@ -79,8 +78,7 @@ uint8_t EEPROMClass::read(int address)
return _data[address]; return _data[address];
} }
void EEPROMClass::write(int address, uint8_t value) void EEPROMClass::write(int address, uint8_t value) {
{
if (address < 0 || (size_t)address >= _size) if (address < 0 || (size_t)address >= _size)
return; return;
if(!_data) if(!_data)
@ -90,8 +88,7 @@ void EEPROMClass::write(int address, uint8_t value)
_dirty = true; _dirty = true;
} }
bool EEPROMClass::commit() bool EEPROMClass::commit() {
{
bool ret = false; bool ret = false;
if (!_size) if (!_size)
return false; return false;
@ -101,8 +98,8 @@ bool EEPROMClass::commit()
return false; return false;
noInterrupts(); noInterrupts();
if(spi_flash_erase_sector(CONFIG_SECTOR) == SPI_FLASH_RESULT_OK) { if(spi_flash_erase_sector(_sector) == SPI_FLASH_RESULT_OK) {
if(spi_flash_write(CONFIG_ADDR, reinterpret_cast<uint32_t*>(_data), _size) == SPI_FLASH_RESULT_OK) { if(spi_flash_write(_sector * SPI_FLASH_SEC_SIZE, reinterpret_cast<uint32_t*>(_data), _size) == SPI_FLASH_RESULT_OK) {
_dirty = false; _dirty = false;
ret = true; ret = true;
} }
@ -112,11 +109,10 @@ bool EEPROMClass::commit()
return ret; return ret;
} }
uint8_t * EEPROMClass::getDataPtr() uint8_t * EEPROMClass::getDataPtr() {
{
_dirty = true; _dirty = true;
return &_data[0]; return &_data[0];
} }
extern "C" uint32_t _SPIFFS_end;
EEPROMClass EEPROM; EEPROMClass EEPROM((((uint32_t)&_SPIFFS_end - 0x40200000) / SPI_FLASH_SEC_SIZE));

25
libraries/EEPROM/EEPROM.h
View File

@ -26,10 +26,10 @@
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
class EEPROMClass class EEPROMClass {
{ public:
public: EEPROMClass(uint32_t sector);
EEPROMClass();
void begin(size_t size); void begin(size_t size);
uint8_t read(int address); uint8_t read(int address);
void write(int address, uint8_t val); void write(int address, uint8_t val);
@ -38,28 +38,27 @@ class EEPROMClass
uint8_t * getDataPtr(); uint8_t * getDataPtr();
template<typename T> T &get(int address, T &t) template<typename T>
{ T &get(int address, T &t) {
if (address < 0 || address + sizeof(T) > _size) if (address < 0 || address + sizeof(T) > _size)
return t; return t;
uint8_t *ptr = (uint8_t*) &t; memcpy((uint8_t*) &t, _data + address, sizeof(T));
memcpy(ptr, _data + address, sizeof(T));
return t; return t;
} }
template<typename T> const T &put(int address, const T &t) template<typename T>
{ const T &put(int address, const T &t) {
if (address < 0 || address + sizeof(T) > _size) if (address < 0 || address + sizeof(T) > _size)
return t; return t;
const uint8_t *ptr = (const uint8_t*) &t; memcpy(_data + address, (const uint8_t*) &t, sizeof(T));
memcpy(_data + address, ptr, sizeof(T));
_dirty = true; _dirty = true;
return t; return t;
} }
protected: protected:
uint32_t _sector;
uint8_t* _data; uint8_t* _data;
size_t _size; size_t _size;
bool _dirty; bool _dirty;

2
libraries/EEPROM/examples/eeprom_write/eeprom_write.ino
View File

@ -22,7 +22,7 @@ void loop()
// need to divide by 4 because analog inputs range from // need to divide by 4 because analog inputs range from
// 0 to 1023 and each byte of the EEPROM can only hold a // 0 to 1023 and each byte of the EEPROM can only hold a
// value from 0 to 255. // value from 0 to 255.
int val = analogRead(0) / 4; int val = analogRead(A0) / 4;
// write the value to the appropriate byte of the EEPROM. // write the value to the appropriate byte of the EEPROM.
// these values will remain there when the board is // these values will remain there when the board is