loading

As you might seen already in our previous article about DS3231 RTC Module, we have identified onboard an EEPROM chip, a 32k AT24C32 one. It is independent from the RTC circuit and conected on the I2C bus, a perfect companion for a WIFI Data Logger System.

The AT24C32 provides 32,768 bits of serial electrically erasable and programmable read only memory (EEPROM) organized as 4096 words of 8 bits each. Might not sound too much but believe it or not you can log 6 months of data or even more on it depending on your application requests and how you organize your data logging.

For example if you save your data in 1byte, you will have enough for around 170 days or 24 weeks! With an added 16 extra location available for bulding data header/date/time/CRC/whatever your needs ask for. And if you still feel it to small, you can use anytime AT24C64, 64k size (8192 x 8), direct drop-in replacement!

Step 1: Features

FEATURES:


• Low-Voltage and Standard-Voltage Operation

– 2.7 (VCC = 2.7V to 5.5V)

– 1.8 (VCC = 1.8V to 5.5V)

• Low-Power Devices (ISB = 2μA at 5.5V) Available

• Internally Organized 4096 x 8

• 2-Wire Serial Interface

• Schmitt Trigger, Filtered Inputs for Noise Suppression

• Bidirectional Data Transfer Protocol

• 100 kHz (1.8V, 2.5V, 2.7V) and 400 kHz (5V) Clock Rate

• Write Protect Pin for Hardware Data Protection

• 32-Byte Page Write Mode (Partial Page Writes Allowed)

• Self-Timed Write Cycle (10 ms max)

• High Reliability

– Endurance: 1 Million Write Cycles

– Data Retention: 100 Years

• Automotive Grade and Extended Temperature Devices Available

• 8-Pin JEDEC PDIP, 8-Pin JEDEC SOIC, 8-Pin EIAJ SOIC, and 8-pin TSSOP Packages

The device’s cascadable feature allows up to 8 devices to share a common I2C bus. The device is optimized for use in many industrial and commercial applications where low power and low voltage operation are essential. In addition, the entire family is available in 2.7V (2.7V to 5.5V) and 1.8V (1.8V to 5.5V)versions.

For more details please see AT24C32 Datasheet

Step 2: ​ What We Will Need

What we will need:

  • CBDB Board or any other ESP8266 module
  • USB adapter (take a look on Part 1 for details how to connect them together)
  • DS3231 Module from previous article
  • For programming we will use NodeMCU, a LUA language interpreter implementation for ESP8266 and for uploading the driver and the software we will use the LuaUploader.

Step 3: Driver Implementation


Driver implementation


To be able to access and properly operate with any kind of memory devices we need at least 3 basic functions implemented: addressing, read and write. Plus the proper I2C bus communication initialisation, ofcourse.

1. Init I2C bus/interface:

        address = 0x50,                         -- A2, A1, A0 = 0
        id = 0

        init = function (self, sda, scl)
               self.id = 0
              i2c.setup(self.id, sda, scl, i2c.SLOW)
        end


ADDRESSING:

The 32K EEPROM requires an 8-bit device address word following a start condition to enable the chip for a read or write operation. It uses the three device address bits A2, A1, A0 to allow as many as eight devices on the same bus. These bits must compare to their corresponding hardwired input pins. The A2, A1, and A0 pins use an internal proprietary circuit that biases them to a logic low condition if the pins are allowed to float.

The eighth bit of the device address is the read/write operation select bit. A read operation is initiated if this bit is high and a write operation is initiated if this bit is low.

2. READ Function


A random read requires a “dummy” byte write sequence to load in the data word address. Once the device address word and data word address are clocked in and acknowledged by the EEPROM, the microcontroller must generate another start condition.

The microcontroller now initiates a current address read by sending a device address with the

read/write select bit high. The EEPROM acknowledges the device address and serially clocks

out the data word. The microcontroller does not respond with a zero but does generate a following

stop condition

       read_EEPROM = function (self, devadr, memadr, length)
            adrh=bit.rshift(memadr, 8)
            adrl=bit.band(memadr,0xff)
            i2c.start(self.id)
            i2c.address(self.id, self.address, i2c.TRANSMITTER)
            i2c.write(self.id, adrh)
            i2c.write(self.id, adrl)
            i2c.stop(self.id)
            i2c.start(self.id)
            i2c.address(self.id, self.address, i2c.RECEIVER)
            c=i2c.read(self.id, length)
            i2c.stop(self.id)
           print(c)
           return  c
      end


3. WRITE Function


A write operation requires two 8-bit data word addresses following the device address word and acknowledgment. Upon receipt of this address, the EEPROM will again respond with a zero and then clock in the first 8-bit data word. Following receipt of the 8-bit data word, the EEPROM will output a zero and the addressing device, such as a microcontroller, must terminate the write sequence with a stop condition.

At this time the EEPROM enters an internally-timed write cycle, tWR, to the nonvolatile memory. All inputs are disabled during this write cycle and the EEPROM will not respond until the write is complete

   write_EEPROM = function (self, devadr, memadr, edata)
       i = 1
       length = string.len(edata)
       adrh=bit.rshift(memadr, 8)
       adrl=bit.band(memadr,0xff)
       i2c.start(self.id)
       i2c.address(self.id, self.address, i2c.TRANSMITTER)
       i2c.write(self.id, adrh)
       i2c.write(self.id, adrl)
       --print(edata)                               --debug only
       --print(string.byte(edata,1))        --debug only
       while i<=length do
          tmr.wdclr()
          i2c.write(self.id,string.byte(edata,i))
          i = i+1
       end
       i2c.stop(self.id)
   end

Step 4: Test It

For testing, pack it together and save the code on ESP as 'eeprom.lua', restart ESP and run:

  require('eeprom')                           -- call for new created AT24C32 Module Driver
  memadr=0x00                                 -- let's read from begining
  sda, scl = 2, 1                             -- I2C pins setup 
  edata="4.321 - Data from the EEPROM"        -- Data to write to EEPROM
  eeprom:init(sda,scl)               -- Init I2C
  eeprom:write_EEPROM(0x50,0,edata)  -- Write Data edata to EEPROM starting with address=0
  eeprom:read_EEPROM(0x50,0,28)      -- Read Data from EEPROM, address=0, length=28

Project Webpage:

http://www.esp8266-projects.com/2015/04/at24c32-i2c-external-eeprom-data-looger.html

<p>Hi TrackerJ,</p><p>I'm working in a similar project but I'm using Arduino IDE for ESP8266. I have some problems trying to set I2C pins. I checked some solutions in ESP8266.com forum but they haven't worked for me. I don't know if you have some experience using I2C in Arduino IDE for ESP8266? and if you can give me any orientation?</p><p>Thanks</p>
<p>Hi man, I was having a similar issue. I found this library on GitHub a few weeks ago and it helped me alot! <a href="https://github.com/costonisp/ESP8266-I2C-OLED" rel="nofollow">https://github.com/costonisp/ESP8266-I2C-OLED</a></p><p>Happy hacking!</p>

About This Instructable

14,834views

36favorites

License:

More by TrackerJ:Arduino - MPDMv4 - Universal AC MAINS Dimmer ESP8266 + Arduino IDE 1.6.4 Portable - Full Quick Install Guide  MAX7219 - 8 Digit LED Display Module Driver for ESP8266 
Add instructable to: