beslan/eeprom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Исправления

Browse Source
This commit is contained in:
Tutukov Beslan
2021-11-12 07:10:36 +03:00
parent f818b6b602
commit f6b04a0135
2 changed files with 856 additions and 881 deletions
Download Patch File Download Diff File Expand all files Collapse all files

367
eeprom.cpp
View File

@@ -25,12 +25,12 @@ Version: 1.0
************************************************************/ ************************************************************/
#include "eeprom.h" #include "eeprom.h"
#define BIT_SET(x,n) (x=x | (0x01<<n)) #define BIT_SET(x, n) (x=x | (0x01<<n))
#define BIT_TEST(x,n) (x & (0x01<<n)) #define BIT_TEST(x, n) (x & (0x01<<n))
#define BIT_CLEAR(x,n) (x=x & ~(0x01<<n)) #define BIT_CLEAR(x, n) (x=x & ~(0x01<<n))
const char * const EEPROM::_name[] = {"24C01","24C02","24C04","24C08","24C16","24C32", const char *const EEPROM::_name[] = {"24C01", "24C02", "24C04", "24C08", "24C16", "24C32",
"24C64","24C128","24C256","24C512","24C1024","24C1025"}; "24C64", "24C128", "24C256", "24C512", "24C1024", "24C1025"};
/** /**
* EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) * EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl)
@@ -42,18 +42,17 @@ const char * const EEPROM::_name[] = {"24C01","24C02","24C04","24C08","24C16","2
* @param type eeprom type (TypeEeprom) * @param type eeprom type (TypeEeprom)
* @return none * @return none
*/ */
EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) {
{
_errnum = EEPROM_NoError; _errnum = EEPROM_NoError;
_type = type; _type = type;
// Check address range // Check address range
_address = address; _address = address;
switch(type) { switch (type) {
case T24C01 : case T24C01 :
case T24C02 : case T24C02 :
if(address > 7) { if (address > 7) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = _address << 1; _address = _address << 1;
@@ -61,7 +60,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
_page_number = 1; _page_number = 1;
break; break;
case T24C04 : case T24C04 :
if(address > 7) { if (address > 7) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = (_address & 0xFE) << 1; _address = (_address & 0xFE) << 1;
@@ -69,7 +68,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
_page_number = 2; _page_number = 2;
break; break;
case T24C08 : case T24C08 :
if(address > 7) { if (address > 7) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = (_address & 0xFC) << 1; _address = (_address & 0xFC) << 1;
@@ -83,7 +82,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
break; break;
case T24C32 : case T24C32 :
case T24C64 : case T24C64 :
if(address > 7) { if (address > 7) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = _address << 1; _address = _address << 1;
@@ -92,7 +91,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
break; break;
case T24C128 : case T24C128 :
case T24C256 : case T24C256 :
if(address > 3) { if (address > 3) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = _address << 1; _address = _address << 1;
@@ -100,7 +99,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
_page_number = 1; _page_number = 1;
break; break;
case T24C512 : case T24C512 :
if(address > 3) { if (address > 3) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = _address << 1; _address = _address << 1;
@@ -108,7 +107,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
_page_number = 1; _page_number = 1;
break; break;
case T24C1024 : case T24C1024 :
if(address > 7) { if (address > 7) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = (_address & 0xFE) << 1; _address = (_address & 0xFE) << 1;
@@ -116,7 +115,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
_page_number = 2; _page_number = 2;
break; break;
case T24C1025 : case T24C1025 :
if(address > 3) { if (address > 3) {
_errnum = EEPROM_BadAddress; _errnum = EEPROM_BadAddress;
} }
_address = _address << 1; _address = _address << 1;
@@ -127,7 +126,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
// Size in bytes // Size in bytes
_size = _type; _size = _type;
if(_type == T24C1025) if (_type == T24C1025)
_size = T24C1024; _size = T24C1024;
// Set I2C frequency // Set I2C frequency
@@ -143,8 +142,7 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2
* @param data byte to write (int8_t) * @param data byte to write (int8_t)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, int8_t data) void EEPROM::write(uint32_t address, int8_t data) {
{
uint8_t page; uint8_t page;
uint8_t addr; uint8_t addr;
uint8_t cmd[3]; uint8_t cmd[3];
@@ -152,24 +150,24 @@ void EEPROM::write(uint32_t address, int8_t data)
int ack; int ack;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address)) { if (!checkAddress(address)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
// Compute page number // Compute page number
page = 0; page = 0;
if(_type < T24C32) if (_type < T24C32)
page = (uint8_t) (address / 256); page = (uint8_t) (address / 256);
// Device address // Device address
addr = EEPROM_Address | _address | (page << 1); addr = EEPROM_Address | _address | (page << 1);
if(_type < T24C32) { if (_type < T24C32) {
len = 2; len = 2;
// Word address // Word address
@@ -177,8 +175,7 @@ void EEPROM::write(uint32_t address, int8_t data)
// Data // Data
cmd[1] = (uint8_t) data; cmd[1] = (uint8_t) data;
} } else {
else {
len = 3; len = 3;
// First word address (MSB) // First word address (MSB)
@@ -191,8 +188,8 @@ void EEPROM::write(uint32_t address, int8_t data)
cmd[2] = (uint8_t) data; cmd[2] = (uint8_t) data;
} }
ack = _i2c.write((int)addr,(char *)cmd,len); ack = _i2c.write((int) addr, (char *) cmd, len);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -211,28 +208,27 @@ void EEPROM::write(uint32_t address, int8_t data)
* @param size number of bytes to write (uint32_t) * @param size number of bytes to write (uint32_t)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, int8_t data[], uint32_t length) void EEPROM::write(uint32_t address, const int8_t data[], uint32_t length) {
{
uint8_t page; uint8_t page;
uint8_t addr = 0; uint8_t addr = 0;
uint8_t blocs,remain; uint8_t blocs, remain;
uint8_t fpart,lpart; uint8_t fpart, lpart;
uint8_t i,j,ind; uint8_t i, j, ind;
uint8_t cmd[129]; uint8_t cmd[129];
int ack; int ack;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address)) { if (!checkAddress(address)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
// Check length // Check length
if(!checkAddress(address + length - 1)) { if (!checkAddress(address + length - 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
@@ -243,27 +239,27 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
// Compute remaining bytes // Compute remaining bytes
remain = length - blocs * _page_write; remain = length - blocs * _page_write;
for(i = 0;i < blocs;i++) { for (i = 0; i < blocs; i++) {
// Compute page number // Compute page number
page = 0; page = 0;
if(_type < T24C32) if (_type < T24C32)
page = (uint8_t) (address / 256); page = (uint8_t) (address / 256);
// Device address // Device address
addr = EEPROM_Address | _address | (page << 1); addr = EEPROM_Address | _address | (page << 1);
if(_type < T24C32) { if (_type < T24C32) {
// Word address // Word address
cmd[0] = (uint8_t) (address - page * 256); cmd[0] = (uint8_t) (address - page * 256);
if((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page if ((uint8_t) ((address + _page_write) / 256) == page) { // Data fit in the same page
// Add data // Add data
for(j = 0;j < _page_write;j++) for (j = 0; j < _page_write; j++)
cmd[j + 1] = (uint8_t) data[i * _page_write + j]; cmd[j + 1] = (uint8_t) data[i * _page_write + j];
// Write data // Write data
ack = _i2c.write((int)addr,(char *)cmd,_page_write + 1); ack = _i2c.write((int) addr, (char *) cmd, _page_write + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -273,18 +269,17 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
// Increment address // Increment address
address += _page_write; address += _page_write;
} } else { // Data on 2 pages. We must split the write
else { // Data on 2 pages. We must split the write
// Number of bytes in current page // Number of bytes in current page
fpart = (page + 1) * 256 - address; fpart = (page + 1) * 256 - address;
// Add data for current page // Add data for current page
for(j = 0;j < fpart;j++) for (j = 0; j < fpart; j++)
cmd[j + 1] = (uint8_t) data[i * _page_write + j]; cmd[j + 1] = (uint8_t) data[i * _page_write + j];
// Write data for current page // Write data for current page
ack = _i2c.write((int)addr,(char *)cmd,fpart + 1); ack = _i2c.write((int) addr, (char *) cmd, fpart + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -295,7 +290,7 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
// Increment address // Increment address
address += fpart; address += fpart;
if(page < _page_number - 1) { if (page < _page_number - 1) {
// Increment page // Increment page
page++; page++;
@@ -312,12 +307,12 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
lpart = _page_write - fpart; lpart = _page_write - fpart;
// Add data for next page // Add data for next page
for(j = 0;j < lpart;j++) for (j = 0; j < lpart; j++)
cmd[j + 1] = (uint8_t) data[ind + j]; cmd[j + 1] = (uint8_t) data[ind + j];
// Write data for next page // Write data for next page
ack = _i2c.write((int)addr,(char *)cmd,lpart + 1); ack = _i2c.write((int) addr, (char *) cmd, lpart + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -329,8 +324,7 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
address += lpart; address += lpart;
} }
} }
} } else {
else {
// First word address (MSB) // First word address (MSB)
cmd[0] = (uint8_t) (address >> 8); cmd[0] = (uint8_t) (address >> 8);
@@ -338,12 +332,12 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
cmd[1] = (uint8_t) address; cmd[1] = (uint8_t) address;
// Add data // Add data
for(j = 0;j < _page_write;j++) for (j = 0; j < _page_write; j++)
cmd[j + 2] = (uint8_t) data[i * _page_write + j]; cmd[j + 2] = (uint8_t) data[i * _page_write + j];
// Write data // Write data
ack = _i2c.write((int)addr,(char *)cmd,_page_write + 2); ack = _i2c.write((int) addr, (char *) cmd, _page_write + 2);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -356,45 +350,44 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
} }
} }
if(remain) { if (remain) {
// Compute page number // Compute page number
page = 0; page = 0;
if(_type < T24C32) if (_type < T24C32)
page = (uint8_t) (address / 256); page = (uint8_t) (address / 256);
// Device address // Device address
addr = EEPROM_Address | _address | (page << 1); addr = EEPROM_Address | _address | (page << 1);
if(_type < T24C32) { if (_type < T24C32) {
// Word address // Word address
cmd[0] = (uint8_t) (address - page * 256); cmd[0] = (uint8_t) (address - page * 256);
if((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page if ((uint8_t) ((address + remain) / 256) == page) { // Data fit in the same page
// Add data for the current page // Add data for the current page
for(j = 0;j < remain;j++) for (j = 0; j < remain; j++)
cmd[j + 1] = (uint8_t) data[blocs * _page_write + j]; cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
// Write data for the current page // Write data for the current page
ack = _i2c.write((int)addr,(char *)cmd,remain + 1); ack = _i2c.write((int) addr, (char *) cmd, remain + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
// Wait end of write // Wait end of write
ready(); ready();
} } else { // Data on 2 pages. We must split the write
else { // Data on 2 pages. We must split the write
// Number of bytes in current page // Number of bytes in current page
fpart = (page + 1) * 256 - address; fpart = (page + 1) * 256 - address;
// Add data for current page // Add data for current page
for(j = 0;j < fpart;j++) for (j = 0; j < fpart; j++)
cmd[j + 1] = (uint8_t) data[blocs * _page_write + j]; cmd[j + 1] = (uint8_t) data[blocs * _page_write + j];
// Write data for current page // Write data for current page
ack = _i2c.write((int)addr,(char *)cmd,fpart + 1); ack = _i2c.write((int) addr, (char *) cmd, fpart + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -405,7 +398,7 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
// Increment address // Increment address
address += fpart; address += fpart;
if(page < _page_number - 1) { if (page < _page_number - 1) {
// Increment page // Increment page
page++; page++;
@@ -422,12 +415,12 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
lpart = remain - fpart; lpart = remain - fpart;
// Add data for next page // Add data for next page
for(j = 0;j < lpart;j++) for (j = 0; j < lpart; j++)
cmd[j + 1] = (uint8_t) data[ind + j]; cmd[j + 1] = (uint8_t) data[ind + j];
// Write data for next page // Write data for next page
ack = _i2c.write((int)addr,(char *)cmd,lpart + 1); ack = _i2c.write((int) addr, (char *) cmd, lpart + 1);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -436,8 +429,7 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
ready(); ready();
} }
} }
} } else {
else {
// Fist word address (MSB) // Fist word address (MSB)
cmd[0] = (uint8_t) (address >> 8); cmd[0] = (uint8_t) (address >> 8);
@@ -445,12 +437,12 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
cmd[1] = (uint8_t) address; cmd[1] = (uint8_t) address;
// Add data for the current page // Add data for the current page
for(j = 0;j < remain;j++) for (j = 0; j < remain; j++)
cmd[j + 2] = (uint8_t) data[blocs * _page_write + j]; cmd[j + 2] = (uint8_t) data[blocs * _page_write + j];
// Write data for the current page // Write data for the current page
ack = _i2c.write((int)addr,(char *)cmd,remain + 2); ack = _i2c.write((int) addr, (char *) cmd, remain + 2);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -470,23 +462,22 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length)
* @param data short to write (int16_t) * @param data short to write (int16_t)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, int16_t data) void EEPROM::write(uint32_t address, int16_t data) {
{
int8_t cmd[2]; int8_t cmd[2];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 1)) { if (!checkAddress(address + 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
memcpy(cmd,&data,2); memcpy(cmd, &data, 2);
write(address,cmd,2); write(address, cmd, 2);
} }
@@ -498,23 +489,22 @@ void EEPROM::write(uint32_t address, int16_t data)
* @param data long to write (int32_t) * @param data long to write (int32_t)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, int32_t data) void EEPROM::write(uint32_t address, int32_t data) {
{
int8_t cmd[4]; int8_t cmd[4];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 3)) { if (!checkAddress(address + 3)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
memcpy(cmd,&data,4); memcpy(cmd, &data, 4);
write(address,cmd,4); write(address, cmd, 4);
} }
@@ -526,23 +516,22 @@ void EEPROM::write(uint32_t address, int32_t data)
* @param data float to write (float) * @param data float to write (float)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, float data) void EEPROM::write(uint32_t address, float data) {
{
int8_t cmd[4]; int8_t cmd[4];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 3)) { if (!checkAddress(address + 3)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
memcpy(cmd,&data,4); memcpy(cmd, &data, 4);
write(address,cmd,4); write(address, cmd, 4);
} }
@@ -555,29 +544,28 @@ void EEPROM::write(uint32_t address, float data)
* @param size number of bytes to write (uint32_t) * @param size number of bytes to write (uint32_t)
* @return none * @return none
*/ */
void EEPROM::write(uint32_t address, void *data, uint32_t size) void EEPROM::write(uint32_t address, void *data, uint32_t size) {
{ int8_t *cmd = nullptr;
int8_t *cmd = NULL;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + size - 1)) { if (!checkAddress(address + size - 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
cmd = (int8_t *)malloc(size); cmd = (int8_t *) malloc(size);
if(cmd == NULL) { if (cmd == nullptr) {
_errnum = EEPROM_MallocError; _errnum = EEPROM_MallocError;
return; return;
} }
memcpy(cmd,(uint8_t *)data,size); memcpy(cmd, (uint8_t *) data, size);
write(address,cmd,size); write(address, cmd, size);
free(cmd); free(cmd);
@@ -591,8 +579,7 @@ void EEPROM::write(uint32_t address, void *data, uint32_t size)
* @param data byte to read (int8_t&) * @param data byte to read (int8_t&)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, int8_t& data) void EEPROM::read(uint32_t address, int8_t &data) {
{
uint8_t page; uint8_t page;
uint8_t addr; uint8_t addr;
uint8_t cmd[2]; uint8_t cmd[2];
@@ -600,49 +587,48 @@ void EEPROM::read(uint32_t address, int8_t& data)
int ack; int ack;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address)) { if (!checkAddress(address)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
// Compute page number // Compute page number
page = 0; page = 0;
if(_type < T24C32) if (_type < T24C32)
page = (uint8_t) (address / 256); page = (uint8_t) (address / 256);
// Device address // Device address
addr = EEPROM_Address | _address | (page << 1); addr = EEPROM_Address | _address | (page << 1);
if(_type < T24C32) { if (_type < T24C32) {
len = 1; len = 1;
// Word address // Word address
cmd[0] = (uint8_t) (address - page * 256); cmd[0] = (uint8_t) (address - page * 256);
} } else {
else {
len = 2; len = 2;
// First word address (MSB) // First word address (MSB)
cmd[0] = (uint8_t) (address >> 8); cmd[0] = (uint8_t) (address >> 8);
// Second word address (LSB) // Second word address (LSB)
cmd[1] = (uint8_t)address; cmd[1] = (uint8_t) address;
} }
// Write command // Write command
ack = _i2c.write((int)addr,(char *)cmd,len,true); ack = _i2c.write((int) addr, (char *) cmd, len, true);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
// Read data // Read data
ack = _i2c.read((int)addr,(char *)&data,sizeof(data)); ack = _i2c.read((int) addr, (char *) &data, sizeof(data));
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -658,8 +644,7 @@ void EEPROM::read(uint32_t address, int8_t& data)
* @param size number of bytes to read (uint32_t) * @param size number of bytes to read (uint32_t)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, int8_t *data, uint32_t size) void EEPROM::read(uint32_t address, int8_t *data, uint32_t size) {
{
uint8_t page; uint8_t page;
uint8_t addr; uint8_t addr;
uint8_t cmd[2]; uint8_t cmd[2];
@@ -667,36 +652,35 @@ void EEPROM::read(uint32_t address, int8_t *data, uint32_t size)
int ack; int ack;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address)) { if (!checkAddress(address)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
// Check size // Check size
if(!checkAddress(address + size - 1)) { if (!checkAddress(address + size - 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
// Compute page number // Compute page number
page = 0; page = 0;
if(_type < T24C32) if (_type < T24C32)
page = (uint8_t) (address / 256); page = (uint8_t) (address / 256);
// Device address // Device address
addr = EEPROM_Address | _address | (page << 1); addr = EEPROM_Address | _address | (page << 1);
if(_type < T24C32) { if (_type < T24C32) {
len = 1; len = 1;
// Word address // Word address
cmd[0] = (uint8_t) (address - page * 256); cmd[0] = (uint8_t) (address - page * 256);
} } else {
else {
len = 2; len = 2;
// First word address (MSB) // First word address (MSB)
@@ -707,15 +691,15 @@ void EEPROM::read(uint32_t address, int8_t *data, uint32_t size)
} }
// Write command // Write command
ack = _i2c.write((int)addr,(char *)cmd,len,true); ack = _i2c.write((int) addr, (char *) cmd, len, true);
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
// Sequential read // Sequential read
ack = _i2c.read((int)addr,(char *)data,size); ack = _i2c.read((int) addr, (char *) data, static_cast<int>(size));
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -729,21 +713,20 @@ void EEPROM::read(uint32_t address, int8_t *data, uint32_t size)
* @param data byte to read (int8_t&) * @param data byte to read (int8_t&)
* @return none * @return none
*/ */
void EEPROM::read(int8_t& data) void EEPROM::read(int8_t &data) {
{
uint8_t addr; uint8_t addr;
int ack; int ack;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Device address // Device address
addr = EEPROM_Address | _address; addr = EEPROM_Address | _address;
// Read data // Read data
ack = _i2c.read((int)addr,(char *)&data,sizeof(data)); ack = _i2c.read((int) addr, (char *) &data, sizeof(data));
if(ack != 0) { if (ack != 0) {
_errnum = EEPROM_I2cError; _errnum = EEPROM_I2cError;
return; return;
} }
@@ -758,23 +741,22 @@ void EEPROM::read(int8_t& data)
* @param data short to read (int16_t&) * @param data short to read (int16_t&)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, int16_t& data) void EEPROM::read(uint32_t address, int16_t &data) {
{
int8_t cmd[2]; int8_t cmd[2];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 1)) { if (!checkAddress(address + 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
read(address,cmd,2); read(address, cmd, 2);
memcpy(&data,cmd,2); memcpy(&data, cmd, 2);
} }
@@ -786,23 +768,22 @@ void EEPROM::read(uint32_t address, int16_t& data)
* @param data long to read (int32_t&) * @param data long to read (int32_t&)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, int32_t& data) void EEPROM::read(uint32_t address, int32_t &data) {
{
int8_t cmd[4]; int8_t cmd[4];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 3)) { if (!checkAddress(address + 3)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
read(address,cmd,4); read(address, cmd, 4);
memcpy(&data,cmd,4); memcpy(&data, cmd, 4);
} }
@@ -814,23 +795,22 @@ void EEPROM::read(uint32_t address, int32_t& data)
* @param data float to read (float&) * @param data float to read (float&)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, float& data) void EEPROM::read(uint32_t address, float &data) {
{
int8_t cmd[4]; int8_t cmd[4];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + 3)) { if (!checkAddress(address + 3)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
read(address,cmd,4); read(address, cmd, 4);
memcpy(&data,cmd,4); memcpy(&data, cmd, 4);
} }
@@ -843,30 +823,29 @@ void EEPROM::read(uint32_t address, float& data)
* @param size number of bytes to read (uint32_t) * @param size number of bytes to read (uint32_t)
* @return none * @return none
*/ */
void EEPROM::read(uint32_t address, void *data, uint32_t size) void EEPROM::read(uint32_t address, void *data, uint32_t size) {
{ int8_t *cmd = nullptr;
int8_t *cmd = NULL;
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Check address // Check address
if(!checkAddress(address + size - 1)) { if (!checkAddress(address + size - 1)) {
_errnum = EEPROM_OutOfRange; _errnum = EEPROM_OutOfRange;
return; return;
} }
cmd = (int8_t *)malloc(size); cmd = (int8_t *) malloc(size);
if(cmd == NULL) { if (cmd == nullptr) {
_errnum = EEPROM_MallocError; _errnum = EEPROM_MallocError;
return; return;
} }
read(address,(int8_t *)cmd,size); read(address, (int8_t *) cmd, size);
memcpy(data,cmd,size); memcpy(data, cmd, size);
free(cmd); free(cmd);
@@ -879,15 +858,14 @@ void EEPROM::read(uint32_t address, void *data, uint32_t size)
* @param none * @param none
* @return none * @return none
*/ */
void EEPROM::clear(void) void EEPROM::clear() {
{
int32_t data; int32_t data;
uint32_t i; uint32_t i;
data = 0; data = 0;
for(i = 0; i < _size / 4;i++) { for (i = 0; i < _size / 4; i++) {
write((uint32_t)(i * 4),data); write((uint32_t) (i * 4), data);
} }
} }
@@ -898,14 +876,13 @@ void EEPROM::clear(void)
* @param none * @param none
* @return none * @return none
*/ */
void EEPROM::ready(void) void EEPROM::ready() {
{
int ack; int ack;
uint8_t addr; uint8_t addr;
uint8_t cmd[2]; uint8_t cmd[2];
// Check error // Check error
if(_errnum) if (_errnum)
return; return;
// Device address // Device address
@@ -915,9 +892,9 @@ void EEPROM::ready(void)
// Wait end of write // Wait end of write
do { do {
ack = _i2c.write((int)addr,(char *)cmd,0); ack = _i2c.write((int) addr, (char *) cmd, 0);
ThisThread::sleep_for(1ms); ThisThread::sleep_for(1ms);
} while(ack != 0); } while (ack != 0);
} }
@@ -928,9 +905,8 @@ void EEPROM::ready(void)
* @param none * @param none
* @return size in bytes (uint32_t) * @return size in bytes (uint32_t)
*/ */
uint32_t EEPROM::getSize(void) uint32_t EEPROM::getSize() {
{ return (_size);
return(_size);
} }
/** /**
@@ -940,11 +916,10 @@ uint32_t EEPROM::getSize(void)
* @param none * @param none
* @return name (const char*) * @return name (const char*)
*/ */
const char* EEPROM::getName(void) const char *EEPROM::getName() {
{
uint8_t i = 0; uint8_t i = 0;
switch(_type) { switch (_type) {
case T24C01 : case T24C01 :
i = 0; i = 0;
break; break;
@@ -983,7 +958,7 @@ const char* EEPROM::getName(void)
break; break;
} }
return(_name[i]); return (_name[i]);
} }
/** /**
@@ -993,9 +968,8 @@ const char* EEPROM::getName(void)
* @param none * @param none
* @return none * @return none
*/ */
uint8_t EEPROM::getError(void) uint8_t EEPROM::getError() {
{ return (_errnum);
return(_errnum);
} }
/** /**
@@ -1005,60 +979,59 @@ uint8_t EEPROM::getError(void)
* @param address address to check (uint32_t) * @param address address to check (uint32_t)
* @return true if in eeprom range, overwise false (bool) * @return true if in eeprom range, overwise false (bool)
*/ */
bool EEPROM::checkAddress(uint32_t address) bool EEPROM::checkAddress(uint32_t address) {
{
bool ret = true; bool ret = true;
switch(_type) { switch (_type) {
case T24C01 : case T24C01 :
if(address >= T24C01) if (address >= T24C01)
ret = false; ret = false;
break; break;
case T24C02 : case T24C02 :
if(address >= T24C02) if (address >= T24C02)
ret = false; ret = false;
break; break;
case T24C04 : case T24C04 :
if(address >= T24C04) if (address >= T24C04)
ret = false; ret = false;
break; break;
case T24C08 : case T24C08 :
if(address >= T24C08) if (address >= T24C08)
ret = false; ret = false;
break; break;
case T24C16 : case T24C16 :
if(address >= T24C16) if (address >= T24C16)
ret = false; ret = false;
break; break;
case T24C32 : case T24C32 :
if(address >= T24C32) if (address >= T24C32)
ret = false; ret = false;
break; break;
case T24C64 : case T24C64 :
if(address >= T24C64) if (address >= T24C64)
ret = false; ret = false;
break; break;
case T24C128 : case T24C128 :
if(address >= T24C128) if (address >= T24C128)
ret = false; ret = false;
break; break;
case T24C256 : case T24C256 :
if(address >= T24C256) if (address >= T24C256)
ret = false; ret = false;
break; break;
case T24C512 : case T24C512 :
if(address >= T24C512) if (address >= T24C512)
ret = false; ret = false;
break; break;
case T24C1024 : case T24C1024 :
if(address >= T24C1024) if (address >= T24C1024)
ret = false; ret = false;
break; break;
case T24C1025 : case T24C1025 :
if(address >= T24C1025 - 1) if (address >= T24C1025 - 1)
ret = false; ret = false;
break; break;
} }
return(ret); return (ret);
} }

40
eeprom.h
View File

@@ -26,15 +26,17 @@ static std::string _ErrorMessageEEPROM[EEPROM_MaxError] = {
"Invalid parameter", "Invalid parameter",
"Data address out of range", "Data address out of range",
"Memory allocation error" "Memory allocation error"
}; };
/** EEPROM Class /** EEPROM Class
*/ */
class EEPROM { class EEPROM {
public: public:
enum TypeEeprom {T24C01=128,T24C02=256,T24C04=512,T24C08=1024,T24C16=2048, enum TypeEeprom {
T24C32=4096,T24C64=8192,T24C128=16384,T24C256=32768, T24C01 = 128, T24C02 = 256, T24C04 = 512, T24C08 = 1024, T24C16 = 2048,
T24C512=65536,T24C1024=131072,T24C1025=131073} Type; T24C32 = 4096, T24C64 = 8192, T24C128 = 16384, T24C256 = 32768,
T24C512 = 65536, T24C1024 = 131072, T24C1025 = 131073
} Type;
/** /**
* Constructor, initialize the eeprom on i2c interface. * Constructor, initialize the eeprom on i2c interface.
@@ -52,7 +54,7 @@ public:
* @param data byte to read (int8_t&) * @param data byte to read (int8_t&)
* @return none * @return none
*/ */
void read(uint32_t address, int8_t& data); void read(uint32_t address, int8_t &data);
/** /**
* Random read short * Random read short
@@ -60,7 +62,7 @@ public:
* @param data short to read (int16_t&) * @param data short to read (int16_t&)
* @return none * @return none
*/ */
void read(uint32_t address, int16_t& data); void read(uint32_t address, int16_t &data);
/** /**
* Random read long * Random read long
@@ -68,7 +70,7 @@ public:
* @param data long to read (int32_t&) * @param data long to read (int32_t&)
* @return none * @return none
*/ */
void read(uint32_t address, int32_t& data); void read(uint32_t address, int32_t &data);
/** /**
* Random read float * Random read float
@@ -76,7 +78,7 @@ public:
* @param data float to read (float&) * @param data float to read (float&)
* @return none * @return none
*/ */
void read(uint32_t address, float& data); void read(uint32_t address, float &data);
/** /**
* Random read anything * Random read anything
@@ -92,7 +94,7 @@ public:
* @param data byte to read (int8_t&) * @param data byte to read (int8_t&)
* @return none * @return none
*/ */
void read(int8_t& data); void read(int8_t &data);
/** /**
* Sequential read byte * Sequential read byte
@@ -151,51 +153,50 @@ public:
* @param size number of bytes to write (uint32_t) * @param size number of bytes to write (uint32_t)
* @return none * @return none
*/ */
void write(uint32_t address, int8_t data[], uint32_t size); void write(uint32_t address, const int8_t data[], uint32_t size);
/** /**
* Wait eeprom ready * Wait eeprom ready
* @param none * @param none
* @return none * @return none
*/ */
void ready(void); void ready();
/** /**
* Get eeprom size in bytes * Get eeprom size in bytes
* @param none * @param none
* @return size in bytes (uint32_t) * @return size in bytes (uint32_t)
*/ */
uint32_t getSize(void); uint32_t getSize();
/** /**
* Get eeprom name * Get eeprom name
* @param none * @param none
* @return name (const char*) * @return name (const char*)
*/ */
const char* getName(void); const char *getName();
/** /**
* Clear eeprom (write with 0) * Clear eeprom (write with 0)
* @param none * @param none
* @return none * @return none
*/ */
void clear(void); void clear();
/** /**
* Get the current error number (EEPROM_NoError if no error) * Get the current error number (EEPROM_NoError if no error)
* @param none * @param none
* @return none * @return none
*/ */
uint8_t getError(void); uint8_t getError();
/** /**
* Get current error message * Get current error message
* @param none * @param none
* @return current error message(std::string) * @return current error message(std::string)
*/ */
std::string getErrorMessage(void) std::string getErrorMessage(void) const {
{ return (_ErrorMessageEEPROM[_errnum]);
return(_ErrorMessageEEPROM[_errnum]);
} }
//---------- local variables ---------- //---------- local variables ----------
@@ -208,7 +209,8 @@ private:
uint8_t _page_number; // Number of page uint8_t _page_number; // Number of page
uint32_t _size; // Size in bytes uint32_t _size; // Size in bytes
bool checkAddress(uint32_t address); // Check address range bool checkAddress(uint32_t address); // Check address range
static const char * const _name[]; // eeprom name static const char *const _name[]; // eeprom name
//------------------------------------- //-------------------------------------
}; };
#endif #endif