Merge pull request RobTillaart#7 from odbol/master

Updated I2C_EEPROM lib for Arduino Due, added support for smaller EEPROM chips

Author: RobTillaart

libraries/I2C_EEPROM/I2C_eeprom.cpp

@@ -26,21 +26,57 @@
 
 #include <I2C_eeprom.h>
 
+#if defined(ARDUINO) && ARDUINO >= 100
+ #define WIRE_WRITE Wire.write
+#else
+ #define WIRE_WRITE Wire.send
+#endif
+
+
 I2C_eeprom::I2C_eeprom(uint8_t device)
 {
  _deviceAddress = device;
+ isAddressSizeTwoWords = true;
+ this->pageSize = I2C_EEPROM_PAGESIZE;
+}
+
+I2C_eeprom::I2C_eeprom(uint8_t device, unsigned int deviceSize) {
+ _deviceAddress = device;
+
+ // Chips 16Kbit (2048KB) or smaller only have one-word addresses.
+ // Also try to guess page size from device size (going by Microchip 24LCXX datasheets here).
+ if (deviceSize > 256 * 8) {
+ this->isAddressSizeTwoWords = true;
+ this->pageSize = 32;
+ }
+ else {
+ this->isAddressSizeTwoWords = false;
+
+ if (deviceSize <= 256) {
+ this->pageSize = 8;
+ }
+ else {
+ this->pageSize = 16;
+ }
+ }
 }
 
 void I2C_eeprom::begin()
 {
  Wire.begin();
  _lastWrite = 0;
+
+// TWBR is not available on Arduino Due
+#ifdef TWBR 
  TWBR = 72;
  // 0=1000 1=888 2=800 8=500
  // 12=400KHz 24=250 32=200 72=100 152=50
  // F_CPU/16+(2*TWBR) // TWBR is a uint8_t
+#endif 
 }
 
+
+
 int I2C_eeprom::writeByte(uint16_t address, uint8_t data)
 {
  int rv = _WriteBlock(address, &data, 1);
@@ -136,7 +172,7 @@ int I2C_eeprom::_pageBlock(uint16_t address, uint8_t* buffer, uint16_t length, b
  int rv = 0;
  while (length > 0)
  {
- uint8_t bytesUntilPageBoundary = I2C_EEPROM_PAGESIZE - address % I2C_EEPROM_PAGESIZE;
+ uint8_t bytesUntilPageBoundary = this->pageSize - address % this->pageSize;
  uint8_t cnt = min(length, bytesUntilPageBoundary);
  cnt = min(cnt, I2C_TWIBUFFERSIZE);
 
@@ -150,22 +186,27 @@ int I2C_eeprom::_pageBlock(uint16_t address, uint8_t* buffer, uint16_t length, b
  return rv;
 }
 
-// pre: length <= I2C_EEPROM_PAGESIZE && length <= I2C_TWIBUFFERSIZE;
+
+void I2C_eeprom::_beginTransmission(uint16_t eeaddress){
+ Wire.beginTransmission(_deviceAddress);
+
+ if (this->isAddressSizeTwoWords) {
+ WIRE_WRITE((eeaddress >> 8)); // Address High Byte 
+ }
+
+ WIRE_WRITE((eeaddress & 0xFF)); // Address Low Byte (or only byte for chips 16K or smaller that only have one-word addresses)
+}
+
+// pre: length <= this->pageSize && length <= I2C_TWIBUFFERSIZE;
 // returns 0 = OK otherwise error
 int I2C_eeprom::_WriteBlock(uint16_t address, uint8_t* buffer, uint8_t length)
 {
  waitEEReady();
 
- Wire.beginTransmission(_deviceAddress);
-#if defined(ARDUINO) && ARDUINO >= 100
- Wire.write(address >> 8);
- Wire.write(address & 0xFF);
- Wire.write(buffer, length);
-#else
- Wire.send(address >> 8);
- Wire.send(address & 0xFF);
- Wire.send(buffer, length);
-#endif
+ this->_beginTransmission(address);
+
+ WIRE_WRITE(buffer, length);
+
  int rv = Wire.endTransmission();
  _lastWrite = micros();
  return rv;
@@ -177,14 +218,8 @@ uint8_t I2C_eeprom::_ReadBlock(uint16_t address, uint8_t* buffer, uint8_t length
 {
  waitEEReady();
 
- Wire.beginTransmission(_deviceAddress);
-#if defined(ARDUINO) && ARDUINO >= 100
- Wire.write(address >> 8);
- Wire.write(address & 0xFF);
-#else
- Wire.send(address >> 8);
- Wire.send(address & 0xFF);
-#endif
+ this->_beginTransmission(address);
+
  int rv = Wire.endTransmission();
  if (rv != 0) return 0; // error
 

libraries/I2C_EEPROM/I2C_eeprom.h

@@ -23,6 +23,7 @@
 
 #define I2C_EEPROM_VERSION "1.1.00"
 
+// The DEFAULT page size. This is overriden if you use the second constructor.
 // I2C_EEPROM_PAGESIZE must be multiple of 2 e.g. 16, 32 or 64
 // 24LC256 -> 64 bytes
 #define I2C_EEPROM_PAGESIZE 64
@@ -40,8 +41,21 @@
 class I2C_eeprom
 {
 public:
+ /**
+ * Initializes the EEPROM with a default pagesize of I2C_EEPROM_PAGESIZE.
+ */
  I2C_eeprom(uint8_t deviceAddress);
 
+ /**
+ * Initializes the EEPROM for the given device address.
+ *
+ * It will try to guess page size and address word size based on the size of the device.
+ * 
+ * @param deviceAddress Byte address of the device.
+ * @param deviceSize Max size in bytes of the device (divide your device size in Kbits by 8)
+ */
+ I2C_eeprom(uint8_t deviceAddress, unsigned int deviceSize);
+
  void begin();
  int writeByte(uint16_t address, uint8_t value);
  int writeBlock(uint16_t address, uint8_t* buffer, uint16_t length);
@@ -58,6 +72,18 @@ class I2C_eeprom
  uint8_t _deviceAddress;
  uint32_t _lastWrite; // for waitEEReady
 
+ uint8_t pageSize;
+
+ // for some smaller chips that use one-word addresses
+ bool isAddressSizeTwoWords;
+
+ /**
+ * Begins wire transmission and selects the given address to write/read.
+ * 
+ * @param eeaddress Address to write/read
+ */
+ void _beginTransmission(uint16_t eeaddress);
+
  int _pageBlock(uint16_t address, uint8_t* buffer, uint16_t length, bool incrBuffer);
  int _WriteBlock(uint16_t address, uint8_t* buffer, uint8_t length);
  uint8_t _ReadBlock(uint16_t address, uint8_t* buffer, uint8_t length);