From 3b9b3f743050ec19d27fa8c8667979e8a7c8ca8b Mon Sep 17 00:00:00 2001 From: Beslan Date: Tue, 15 Dec 2020 19:56:18 +0300 Subject: [PATCH] =?UTF-8?q?=D0=BD=D0=B0=D1=87=D0=B0=D0=BB=D1=8C=D0=BD?= =?UTF-8?q?=D1=8B=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- eeprom.cpp | 1064 ++++++++++++++++++++++++++++++++++++++++++++++++++++ eeprom.h | 214 +++++++++++ 2 files changed, 1278 insertions(+) create mode 100644 eeprom.cpp create mode 100644 eeprom.h diff --git a/eeprom.cpp b/eeprom.cpp new file mode 100644 index 0000000..816bf1b --- /dev/null +++ b/eeprom.cpp @@ -0,0 +1,1064 @@ +/*********************************************************** +Author: Bernard Borredon +Version: 1.3 + - Correct write(uint32_t address, int8_t data[], uint32_t length) for eeprom >= T24C32. + Tested with 24C02, 24C08, 24C16, 24C64, 24C256, 24C512, 24C1025 on LPC1768 (mbed online and µVision V5.16a). + - Correct main test. + +Date : 12 decembre 2013 +Version: 1.2 + - Update api documentation + +Date: 11 december 2013 +Version: 1.1 + - Change address parameter size form uint16_t to uint32_t (error for eeprom > 24C256). + - Change size parameter size from uint16_t to uint32_t (error for eeprom > 24C256). + - Correct a bug in function write(uint32_t address, int8_t data[], uint32_t length) : + last step must be done only if it remain datas to send. + - Add function getName. + - Add function clear. + - Initialize _name array. + +Date: 27 december 2011 +Version: 1.0 + +************************************************************/ +#include "eeprom.h" + +#define BIT_SET(x,n) (x=x | (0x01< 7) { + _errnum = EEPROM_BadAddress; + } + _address = _address << 1; + _page_write = 8; + _page_number = 1; + break; + case T24C04 : + if(address > 7) { + _errnum = EEPROM_BadAddress; + } + _address = (_address & 0xFE) << 1; + _page_write = 16; + _page_number = 2; + break; + case T24C08 : + if(address > 7) { + _errnum = EEPROM_BadAddress; + } + _address = (_address & 0xFC) << 1; + _page_write = 16; + _page_number = 4; + break; + case T24C16 : + _address = 0; + _page_write = 16; + _page_number = 8; + break; + case T24C32 : + case T24C64 : + if(address > 7) { + _errnum = EEPROM_BadAddress; + } + _address = _address << 1; + _page_write = 32; + _page_number = 1; + break; + case T24C128 : + case T24C256 : + if(address > 3) { + _errnum = EEPROM_BadAddress; + } + _address = _address << 1; + _page_write = 64; + _page_number = 1; + break; + case T24C512 : + if(address > 3) { + _errnum = EEPROM_BadAddress; + } + _address = _address << 1; + _page_write = 128; + _page_number = 1; + break; + case T24C1024 : + if(address > 7) { + _errnum = EEPROM_BadAddress; + } + _address = (_address & 0xFE) << 1; + _page_write = 128; + _page_number = 2; + break; + case T24C1025 : + if(address > 3) { + _errnum = EEPROM_BadAddress; + } + _address = _address << 1; + _page_write = 128; + _page_number = 2; + break; + } + + // Size in bytes + _size = _type; + if(_type == T24C1025) + _size = T24C1024; + + // Set I2C frequency + _i2c.frequency(400000); + +} + +/** + * void write(uint32_t address, int8_t data) + * + * Write byte + * @param address start address (uint32_t) + * @param data byte to write (int8_t) + * @return none +*/ +void EEPROM::write(uint32_t address, int8_t data) +{ + uint8_t page; + uint8_t addr; + uint8_t cmd[3]; + int len; + int ack; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Compute page number + page = 0; + if(_type < T24C32) + page = (uint8_t) (address / 256); + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + if(_type < T24C32) { + len = 2; + + // Word address + cmd[0] = (uint8_t) (address - page * 256); + + // Data + cmd[1] = (uint8_t) data; + } + else { + len = 3; + + // First word address (MSB) + cmd[0] = (uint8_t) (address >> 8); + + // Second word address (LSB) + cmd[1] = (uint8_t) address; + + // Data + cmd[2] = (uint8_t) data; + } + + ack = _i2c.write((int)addr,(char *)cmd,len); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + +} + +/** + * void write(uint32_t address, int8_t data[], uint32_t length) + * + * Write array of bytes (use the page mode) + * @param address start address (uint32_t) + * @param data bytes array to write (int8_t[]) + * @param size number of bytes to write (uint32_t) + * @return none +*/ +void EEPROM::write(uint32_t address, int8_t data[], uint32_t length) +{ + uint8_t page; + uint8_t addr = 0; + uint8_t blocs,remain; + uint8_t fpart,lpart; + uint8_t i,j,ind; + uint8_t cmd[129]; + int ack; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Check length + if(!checkAddress(address + length - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Compute blocs numbers + blocs = length / _page_write; + + // Compute remaining bytes + remain = length - blocs * _page_write; + + for(i = 0;i < blocs;i++) { + // Compute page number + page = 0; + if(_type < T24C32) + page = (uint8_t) (address / 256); + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + if(_type < T24C32) { + // Word address + cmd[0] = (uint8_t) (address - page * 256); + + if((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page + // Add data + for(j = 0;j < _page_write;j++) + cmd[j + 1] = (uint8_t) data[i * _page_write + j]; + + // Write data + ack = _i2c.write((int)addr,(char *)cmd,_page_write + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + + // Increment address + address += _page_write; + } + else { // Data on 2 pages. We must split the write + // Number of bytes in current page + fpart = (page + 1) * 256 - address; + + // Add data for current page + for(j = 0;j < fpart;j++) + cmd[j + 1] = (uint8_t) data[i * _page_write + j]; + + // Write data for current page + ack = _i2c.write((int)addr,(char *)cmd,fpart + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + + // Increment address + address += fpart; + + if(page < _page_number - 1) { + // Increment page + page++; + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + // Word address + cmd[0] = (uint8_t) (address - page * 256); + + // Data index + ind = i * _page_write + fpart; + + // Number of bytes in next page + lpart = _page_write - fpart; + + // Add data for next page + for(j = 0;j < lpart;j++) + cmd[j + 1] = (uint8_t) data[ind + j]; + + // Write data for next page + ack = _i2c.write((int)addr,(char *)cmd,lpart + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + + // Increment address + address += lpart; + } + } + } + else { + // First word address (MSB) + cmd[0] = (uint8_t) (address >> 8); + + // Second word address (LSB) + cmd[1] = (uint8_t) address; + + // Add data + for(j = 0;j < _page_write;j++) + cmd[j + 2] = (uint8_t) data[i * _page_write + j]; + + // Write data + ack = _i2c.write((int)addr,(char *)cmd,_page_write + 2); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + + // Increment address + address += _page_write; + } + } + + if(remain) { + // Compute page number + page = 0; + if(_type < T24C32) + page = (uint8_t) (address / 256); + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + if(_type < T24C32) { + // Word address + cmd[0] = (uint8_t) (address - page * 256); + + if((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page + // Add data for the current page + for(j = 0;j < remain;j++) + cmd[j + 1] = (uint8_t) data[blocs * _page_write + j]; + + // Write data for the current page + ack = _i2c.write((int)addr,(char *)cmd,remain + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + } + else { // Data on 2 pages. We must split the write + // Number of bytes in current page + fpart = (page + 1) * 256 - address; + + // Add data for current page + for(j = 0;j < fpart;j++) + cmd[j + 1] = (uint8_t) data[blocs * _page_write + j]; + + // Write data for current page + ack = _i2c.write((int)addr,(char *)cmd,fpart + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + + // Increment address + address += fpart; + + if(page < _page_number - 1) { + // Increment page + page++; + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + // Word address + cmd[0] = (uint8_t) (address - page * 256); + + // Data index + ind = blocs * _page_write + fpart; + + // Number of bytes in next page + lpart = remain - fpart; + + // Add data for next page + for(j = 0;j < lpart;j++) + cmd[j + 1] = (uint8_t) data[ind + j]; + + // Write data for next page + ack = _i2c.write((int)addr,(char *)cmd,lpart + 1); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + } + } + } + else { + // Fist word address (MSB) + cmd[0] = (uint8_t) (address >> 8); + + // Second word address (LSB) + cmd[1] = (uint8_t) address; + + // Add data for the current page + for(j = 0;j < remain;j++) + cmd[j + 2] = (uint8_t) data[blocs * _page_write + j]; + + // Write data for the current page + ack = _i2c.write((int)addr,(char *)cmd,remain + 2); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Wait end of write + ready(); + } + } + +} + +/** + * void write(uint32_t address, int16_t data) + * + * Write short + * @param address start address (uint32_t) + * @param data short to write (int16_t) + * @return none +*/ +void EEPROM::write(uint32_t address, int16_t data) +{ + int8_t cmd[2]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + memcpy(cmd,&data,2); + + write(address,cmd,2); + +} + +/** + * void write(uint32_t address, int32_t data) + * + * Write long + * @param address start address (uint32_t) + * @param data long to write (int32_t) + * @return none +*/ +void EEPROM::write(uint32_t address, int32_t data) +{ + int8_t cmd[4]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 3)) { + _errnum = EEPROM_OutOfRange; + return; + } + + memcpy(cmd,&data,4); + + write(address,cmd,4); + +} + +/** + * void write(uint32_t address, float data) + * + * Write float + * @param address start address (uint32_t) + * @param data float to write (float) + * @return none +*/ +void EEPROM::write(uint32_t address, float data) +{ + int8_t cmd[4]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 3)) { + _errnum = EEPROM_OutOfRange; + return; + } + + memcpy(cmd,&data,4); + + write(address,cmd,4); + +} + +/** + * void write(uint32_t address, void *data, uint32_t size) + * + * Write anything (use the page write mode) + * @param address start address (uint32_t) + * @param data data to write (void *) + * @param size number of bytes to write (uint32_t) + * @return none +*/ +void EEPROM::write(uint32_t address, void *data, uint32_t size) +{ + int8_t *cmd = NULL; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + size - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + cmd = (int8_t *)malloc(size); + if(cmd == NULL) { + _errnum = EEPROM_MallocError; + return; + } + + memcpy(cmd,(uint8_t *)data,size); + + write(address,cmd,size); + + free(cmd); + +} + +/** + * void read(uint32_t address, int8_t& data) + * + * Random read byte + * @param address start address (uint32_t) + * @param data byte to read (int8_t&) + * @return none +*/ +void EEPROM::read(uint32_t address, int8_t& data) +{ + uint8_t page; + uint8_t addr; + uint8_t cmd[2]; + uint8_t len; + int ack; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Compute page number + page = 0; + if(_type < T24C32) + page = (uint8_t) (address / 256); + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + if(_type < T24C32) { + len = 1; + + // Word address + cmd[0] = (uint8_t) (address - page * 256); + } + else { + len = 2; + + // First word address (MSB) + cmd[0] = (uint8_t) (address >> 8); + + // Second word address (LSB) + cmd[1] = (uint8_t)address; + } + + // Write command + ack = _i2c.write((int)addr,(char *)cmd,len,true); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Read data + ack = _i2c.read((int)addr,(char *)&data,sizeof(data)); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + +} + +/** + * void read(uint32_t address, int8_t *data, uint32_t size) + * + * Sequential read byte + * @param address start address (uint32_t) + * @param data bytes array to read (int8_t[]&) + * @param size number of bytes to read (uint32_t) + * @return none +*/ +void EEPROM::read(uint32_t address, int8_t *data, uint32_t size) +{ + uint8_t page; + uint8_t addr; + uint8_t cmd[2]; + uint8_t len; + int ack; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Check size + if(!checkAddress(address + size - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + // Compute page number + page = 0; + if(_type < T24C32) + page = (uint8_t) (address / 256); + + // Device address + addr = EEPROM_Address | _address | (page << 1); + + if(_type < T24C32) { + len = 1; + + // Word address + cmd[0] = (uint8_t) (address - page * 256); + } + else { + len = 2; + + // First word address (MSB) + cmd[0] = (uint8_t) (address >> 8); + + // Second word address (LSB) + cmd[1] = (uint8_t) address; + } + + // Write command + ack = _i2c.write((int)addr,(char *)cmd,len,true); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + + // Sequential read + ack = _i2c.read((int)addr,(char *)data,size); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + +} + +/** + * void read(int8_t& data) + * + * Current address read byte + * @param data byte to read (int8_t&) + * @return none + */ +void EEPROM::read(int8_t& data) +{ + uint8_t addr; + int ack; + + // Check error + if(_errnum) + return; + + // Device address + addr = EEPROM_Address | _address; + + // Read data + ack = _i2c.read((int)addr,(char *)&data,sizeof(data)); + if(ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + +} + +/** + * void read(uint32_t address, int16_t& data) + * + * Random read short + * @param address start address (uint32_t) + * @param data short to read (int16_t&) + * @return none +*/ +void EEPROM::read(uint32_t address, int16_t& data) +{ + int8_t cmd[2]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + read(address,cmd,2); + + memcpy(&data,cmd,2); + +} + +/** + * void read(uint32_t address, int32_t& data) + * + * Random read long + * @param address start address (uint32_t) + * @param data long to read (int32_t&) + * @return none +*/ +void EEPROM::read(uint32_t address, int32_t& data) +{ + int8_t cmd[4]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 3)) { + _errnum = EEPROM_OutOfRange; + return; + } + + read(address,cmd,4); + + memcpy(&data,cmd,4); + +} + +/** + * void read(uint32_t address, float& data) + * + * Random read float + * @param address start address (uint32_t) + * @param data float to read (float&) + * @return none + */ +void EEPROM::read(uint32_t address, float& data) +{ + int8_t cmd[4]; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + 3)) { + _errnum = EEPROM_OutOfRange; + return; + } + + read(address,cmd,4); + + memcpy(&data,cmd,4); + +} + +/** + * void read(uint32_t address, void *data, uint32_t size) + * + * Random read anything + * @param address start address (uint32_t) + * @param data data to read (void *) + * @param size number of bytes to read (uint32_t) + * @return none +*/ +void EEPROM::read(uint32_t address, void *data, uint32_t size) +{ + int8_t *cmd = NULL; + + // Check error + if(_errnum) + return; + + // Check address + if(!checkAddress(address + size - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + cmd = (int8_t *)malloc(size); + + if(cmd == NULL) { + _errnum = EEPROM_MallocError; + return; + } + + read(address,(int8_t *)cmd,size); + + memcpy(data,cmd,size); + + free(cmd); + +} + +/** + * void clear(void) + * + * Clear eeprom (write with 0) + * @param none + * @return none + */ +void EEPROM::clear(void) +{ + int32_t data; + uint32_t i; + + data = 0; + + for(i = 0; i < _size / 4;i++) { + write((uint32_t)(i * 4),data); + } +} + +/** + * void ready(void) + * + * Wait eeprom ready + * @param none + * @return none +*/ +void EEPROM::ready(void) +{ + int ack; + uint8_t addr; + uint8_t cmd[2]; + + // Check error + if(_errnum) + return; + + // Device address + addr = EEPROM_Address | _address; + + cmd[0] = 0; + + // Wait end of write + do { + ack = _i2c.write((int)addr,(char *)cmd,0); + //wait(0.5); + } while(ack != 0); + +} + +/** + * uint32_t getSize(void) + * + * Get eeprom size in bytes + * @param none + * @return size in bytes (uint32_t) +*/ +uint32_t EEPROM::getSize(void) +{ + return(_size); +} + +/** + * const char* getName(void) + * + * Get eeprom name + * @param none + * @return name (const char*) + */ +const char* EEPROM::getName(void) +{ + uint8_t i = 0; + + switch(_type) { + case T24C01 : + i = 0; + break; + case T24C02 : + i = 1; + break; + case T24C04 : + i = 2; + break; + case T24C08 : + i = 3; + break; + case T24C16 : + i = 4; + break; + case T24C32 : + i = 5; + break; + case T24C64 : + i = 6; + break; + case T24C128 : + i = 7; + break; + case T24C256 : + i = 8; + break; + case T24C512 : + i = 9; + break; + case T24C1024 : + i = 10; + break; + case T24C1025 : + i = 11; + break; + } + + return(_name[i]); +} + +/** + * uint8_t getError(void) + * + * Get the current error number (EEPROM_NoError if no error) + * @param none + * @return none +*/ +uint8_t EEPROM::getError(void) +{ + return(_errnum); +} + +/** + * bool checkAddress(uint32_t address) + * + * Check if address is in the eeprom range address + * @param address address to check (uint32_t) + * @return true if in eeprom range, overwise false (bool) +*/ +bool EEPROM::checkAddress(uint32_t address) +{ + bool ret = true; + + switch(_type) { + case T24C01 : + if(address >= T24C01) + ret = false; + break; + case T24C02 : + if(address >= T24C02) + ret = false; + break; + case T24C04 : + if(address >= T24C04) + ret = false; + break; + case T24C08 : + if(address >= T24C08) + ret = false; + break; + case T24C16 : + if(address >= T24C16) + ret = false; + break; + case T24C32 : + if(address >= T24C32) + ret = false; + break; + case T24C64 : + if(address >= T24C64) + ret = false; + break; + case T24C128 : + if(address >= T24C128) + ret = false; + break; + case T24C256 : + if(address >= T24C256) + ret = false; + break; + case T24C512 : + if(address >= T24C512) + ret = false; + break; + case T24C1024 : + if(address >= T24C1024) + ret = false; + break; + case T24C1025 : + if(address >= T24C1025 - 1) + ret = false; + break; + } + + return(ret); +} diff --git a/eeprom.h b/eeprom.h new file mode 100644 index 0000000..d8e172e --- /dev/null +++ b/eeprom.h @@ -0,0 +1,214 @@ +#ifndef __EEPROM__H_ +#define __EEPROM__H_ + + +// Includes +#include + +#include "mbed.h" + +// Defines +#define EEPROM_Address 0xa0 + +#define EEPROM_NoError 0x00 +#define EEPROM_BadAddress 0x01 +#define EEPROM_I2cError 0x02 +#define EEPROM_ParamError 0x03 +#define EEPROM_OutOfRange 0x04 +#define EEPROM_MallocError 0x05 + +#define EEPROM_MaxError 6 + +static std::string _ErrorMessageEEPROM[EEPROM_MaxError] = { + "", + "Bad chip address", + "I2C error (nack)", + "Invalid parameter", + "Data address out of range", + "Memory allocation error" + }; + +/** EEPROM Class +*/ +class EEPROM { +public: + enum TypeEeprom {T24C01=128,T24C02=256,T24C04=512,T24C08=1024,T24C16=2048, + T24C32=4096,T24C64=8192,T24C128=16384,T24C256=32768, + T24C512=65536,T24C1024=131072,T24C1025=131073} Type; + + /** + * Constructor, initialize the eeprom on i2c interface. + * @param sda sda i2c pin (PinName) + * @param scl scl i2c pin (PinName) + * @param address eeprom address, according to eeprom type (uint8_t) + * @param type eeprom type (TypeEeprom) + * @return none + */ + EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type); + + /** + * Random read byte + * @param address start address (uint32_t) + * @param data byte to read (int8_t&) + * @return none + */ + void read(uint32_t address, int8_t& data); + + /** + * Random read short + * @param address start address (uint32_t) + * @param data short to read (int16_t&) + * @return none + */ + void read(uint32_t address, int16_t& data); + + /** + * Random read long + * @param address start address (uint32_t) + * @param data long to read (int32_t&) + * @return none + */ + void read(uint32_t address, int32_t& data); + + /** + * Random read float + * @param address start address (uint32_t) + * @param data float to read (float&) + * @return none + */ + void read(uint32_t address, float& data); + + /** + * Random read anything + * @param address start address (uint32_t) + * @param data data to read (void *) + * @param size number of bytes to read (uint32_t) + * @return none + */ + void read(uint32_t address, void *data, uint32_t size); + + /** + * Current address read byte + * @param data byte to read (int8_t&) + * @return none + */ + void read(int8_t& data); + + /** + * Sequential read byte + * @param address start address (uint32_t) + * @param data bytes array to read (int8_t[]&) + * @param size number of bytes to read (uint32_t) + * @return none + */ + void read(uint32_t address, int8_t *data, uint32_t size); + + /** + * Write byte + * @param address start address (uint32_t) + * @param data byte to write (int8_t) + * @return none + */ + void write(uint32_t address, int8_t data); + + /** + * Write short + * @param address start address (uint32_t) + * @param data short to write (int16_t) + * @return none + */ + void write(uint32_t address, int16_t data); + + /** + * Write long + * @param address start address (uint32_t) + * @param data long to write (int32_t) + * @return none + */ + void write(uint32_t address, int32_t data); + + /** + * Write float + * @param address start address (uint32_t) + * @param data float to write (float) + * @return none + */ + void write(uint32_t address, float data); + + /** + * Write anything (use the page write mode) + * @param address start address (uint32_t) + * @param data data to write (void *) + * @param size number of bytes to write (uint32_t) + * @return none + */ + void write(uint32_t address, void *data, uint32_t size); + + /** + * Write array of bytes (use the page mode) + * @param address start address (uint32_t) + * @param data bytes array to write (int8_t[]) + * @param size number of bytes to write (uint32_t) + * @return none + */ + void write(uint32_t address, int8_t data[], uint32_t size); + + /** + * Wait eeprom ready + * @param none + * @return none + */ + void ready(void); + + /** + * Get eeprom size in bytes + * @param none + * @return size in bytes (uint32_t) + */ + uint32_t getSize(void); + + /** + * Get eeprom name + * @param none + * @return name (const char*) + */ + const char* getName(void); + + /** + * Clear eeprom (write with 0) + * @param none + * @return none + */ + void clear(void); + + /** + * Get the current error number (EEPROM_NoError if no error) + * @param none + * @return none + */ + uint8_t getError(void); + + /** + * Get current error message + * @param none + * @return current error message(std::string) + */ + std::string getErrorMessage(void) + { + return(_ErrorMessageEEPROM[_errnum]); + } + +//---------- local variables ---------- +private: + I2C _i2c; // Local i2c communication interface instance + int _address; // Local i2c address + uint8_t _errnum; // Error number + TypeEeprom _type; // EEPROM type + uint8_t _page_write; // Page write size + uint8_t _page_number; // Number of page + uint32_t _size; // Size in bytes + bool checkAddress(uint32_t address); // Check address range + static const char * const _name[]; // eeprom name +//------------------------------------- +}; +#endif