From f6b04a01350b9e1e6499fb4b274a9eb9c649f7ca Mon Sep 17 00:00:00 2001 From: Tutukov Beslan Date: Fri, 12 Nov 2021 07:10:36 +0300 Subject: [PATCH] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- eeprom.cpp | 1631 ++++++++++++++++++++++++++-------------------------- eeprom.h | 106 ++-- 2 files changed, 856 insertions(+), 881 deletions(-) diff --git a/eeprom.cpp b/eeprom.cpp index ac4695b..38855b5 100644 --- a/eeprom.cpp +++ b/eeprom.cpp @@ -25,12 +25,12 @@ 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); +EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2c(sda, scl) { + + _errnum = EEPROM_NoError; + _type = type; + + // Check address range + _address = address; + switch (type) { + case T24C01 : + case T24C02 : + if (address > 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); } @@ -143,62 +142,60 @@ EEPROM::EEPROM(PinName sda, PinName scl, uint8_t address, TypeEeprom type) : _i2 * @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 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(); } @@ -211,255 +208,250 @@ void EEPROM::write(uint32_t address, int8_t data) * @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; +void EEPROM::write(uint32_t address, const 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; - // 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; + // Check error + if (_errnum) return; - } - - // Wait end of write - ready(); + + // 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(); + } + } + } /** @@ -470,24 +462,23 @@ void EEPROM::write(uint32_t address, int8_t data[], uint32_t length) * @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 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); + } /** @@ -498,24 +489,23 @@ void EEPROM::write(uint32_t address, int16_t data) * @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 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); + } /** @@ -526,24 +516,23 @@ void EEPROM::write(uint32_t address, int32_t data) * @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 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); + } /** @@ -555,32 +544,31 @@ void EEPROM::write(uint32_t address, float data) * @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 EEPROM::write(uint32_t address, void *data, uint32_t size) { + int8_t *cmd = nullptr; + + // Check error + if (_errnum) + return; + + // Check address + if (!checkAddress(address + size - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + cmd = (int8_t *) malloc(size); + if (cmd == nullptr) { + _errnum = EEPROM_MallocError; + return; + } + + memcpy(cmd, (uint8_t *) data, size); + + write(address, cmd, size); + + free(cmd); + } /** @@ -591,62 +579,60 @@ void EEPROM::write(uint32_t address, void *data, uint32_t size) * @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 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; + } + } /** @@ -658,68 +644,66 @@ void EEPROM::read(uint32_t address, int8_t& data) * @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 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, static_cast(size)); + if (ack != 0) { + _errnum = EEPROM_I2cError; + return; + } + } /** @@ -729,25 +713,24 @@ void EEPROM::read(uint32_t address, int8_t *data, uint32_t size) * @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; +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; + } - // Read data - ack = _i2c.read((int)addr,(char *)&data,sizeof(data)); - if(ack != 0) { - _errnum = EEPROM_I2cError; - return; - } - } /** @@ -758,24 +741,23 @@ void EEPROM::read(int8_t& data) * @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 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); + } /** @@ -786,24 +768,23 @@ void EEPROM::read(uint32_t address, int16_t& data) * @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 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); + } /** @@ -814,24 +795,23 @@ void EEPROM::read(uint32_t address, int32_t& data) * @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 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); + } /** @@ -843,33 +823,32 @@ void EEPROM::read(uint32_t address, float& data) * @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); +void EEPROM::read(uint32_t address, void *data, uint32_t size) { + int8_t *cmd = nullptr; + + // Check error + if (_errnum) + return; + + // Check address + if (!checkAddress(address + size - 1)) { + _errnum = EEPROM_OutOfRange; + return; + } + + cmd = (int8_t *) malloc(size); + + if (cmd == nullptr) { + _errnum = EEPROM_MallocError; + return; + } + + read(address, (int8_t *) cmd, size); + + memcpy(data, cmd, size); + + free(cmd); - if(cmd == NULL) { - _errnum = EEPROM_MallocError; - return; - } - - read(address,(int8_t *)cmd,size); - - memcpy(data,cmd,size); - - free(cmd); - } /** @@ -879,16 +858,15 @@ void EEPROM::read(uint32_t address, void *data, uint32_t size) * @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 EEPROM::clear() { + int32_t data; + uint32_t i; + + data = 0; + + for (i = 0; i < _size / 4; i++) { + write((uint32_t) (i * 4), data); + } } /** @@ -898,26 +876,25 @@ void EEPROM::clear(void) * @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); - ThisThread::sleep_for(1ms); - } while(ack != 0); +void EEPROM::ready() { + 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); + ThisThread::sleep_for(1ms); + } while (ack != 0); } @@ -928,9 +905,8 @@ void EEPROM::ready(void) * @param none * @return size in bytes (uint32_t) */ -uint32_t EEPROM::getSize(void) -{ - return(_size); +uint32_t EEPROM::getSize() { + return (_size); } /** @@ -940,50 +916,49 @@ uint32_t EEPROM::getSize(void) * @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]); +const char *EEPROM::getName() { + 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]); } /** @@ -993,9 +968,8 @@ const char* EEPROM::getName(void) * @param none * @return none */ -uint8_t EEPROM::getError(void) -{ - return(_errnum); +uint8_t EEPROM::getError() { + return (_errnum); } /** @@ -1005,60 +979,59 @@ uint8_t EEPROM::getError(void) * @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); +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 index d8e172e..1bb18d1 100644 --- a/eeprom.h +++ b/eeprom.h @@ -3,7 +3,7 @@ // Includes -#include +#include #include "mbed.h" @@ -20,22 +20,24 @@ #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" - }; + "", + "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; - + 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) @@ -45,39 +47,39 @@ public: * @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); - + 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); - + 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); - + 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); - + void read(uint32_t address, float &data); + /** * Random read anything * @param address start address (uint32_t) @@ -86,14 +88,14 @@ public: * @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); - + void read(int8_t &data); + /** * Sequential read byte * @param address start address (uint32_t) @@ -102,7 +104,7 @@ public: * @return none */ void read(uint32_t address, int8_t *data, uint32_t size); - + /** * Write byte * @param address start address (uint32_t) @@ -110,7 +112,7 @@ public: * @return none */ void write(uint32_t address, int8_t data); - + /** * Write short * @param address start address (uint32_t) @@ -118,7 +120,7 @@ public: * @return none */ void write(uint32_t address, int16_t data); - + /** * Write long * @param address start address (uint32_t) @@ -126,7 +128,7 @@ public: * @return none */ void write(uint32_t address, int32_t data); - + /** * Write float * @param address start address (uint32_t) @@ -134,7 +136,7 @@ public: * @return none */ void write(uint32_t address, float data); - + /** * Write anything (use the page write mode) * @param address start address (uint32_t) @@ -143,7 +145,7 @@ public: * @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) @@ -151,53 +153,52 @@ public: * @param size number of bytes to write (uint32_t) * @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 * @param none * @return none */ - void ready(void); - + void ready(); + /** * Get eeprom size in bytes * @param none * @return size in bytes (uint32_t) */ - uint32_t getSize(void); - + uint32_t getSize(); + /** * Get eeprom name * @param none * @return name (const char*) */ - const char* getName(void); - + const char *getName(); + /** * 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); - + void clear(); + + /** + * Get the current error number (EEPROM_NoError if no error) + * @param none + * @return none + */ + uint8_t getError(); + /** * Get current error message * @param none * @return current error message(std::string) */ - std::string getErrorMessage(void) - { - return(_ErrorMessageEEPROM[_errnum]); + std::string getErrorMessage(void) const { + return (_ErrorMessageEEPROM[_errnum]); } - + //---------- local variables ---------- private: I2C _i2c; // Local i2c communication interface instance @@ -208,7 +209,8 @@ private: 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 + static const char *const _name[]; // eeprom name //------------------------------------- }; + #endif