for all the things you do...

Adding Memory with i2c EEPROMs

It doesn't take long to start running out of memory in microcontroller projects - especially if the project involves storing data gathered from sensors and other inputs. Fortunately, it is easy and inexpensive to add quite a bit of data storage capacity using serial EEPROM chips. This tutorial will provide an introduction to interfacing PICAXE processors with the Microchip 24LC16B and 24LC256 i2c EEPROMs. While there are many other options, these particular EEPROMs are inexpensive and readily available from both PICAXE vendors and general electronics hobby suppliers. Additionally, their use is extremely well documented. They are the EEPROMs used in the Revolution Education AXE110 datalogger and the AXE111 memory expansion board, as well as many third party project designs.

EEPROM stands for electrically erasable programmable read-only memory. EEPROM is a non-volatile memory which means that unlike RAM, its contents will be preserved even when power is removed from the circuit. All PICAXE processors have some EEPROM built-in; it is used for both program and data storage. Microchip Technology, the manufacturer of the PIC processors on which all PICAXE microcontrollers are based, produces a large variety of serial EEPROMs for many different applications.

i2c and PICAXE

The i2c (inter-integrated circuit) protocol is a widely implemented method for moving data back and forth among integrated circuits. All of the X, X1 and X2 PICAXE parts support the i2c protocol. In i2c a potentially large number of devices are all connected via a simple two-wire serial bus. The protocol establishes master-slave relationships among the devices. Every slave device on the i2c bus is identified by a unique address. Sometimes this address is built into the IC itself, other times it is configured within the circuit design.

A typical simple configuration would have a microcontroller such as the PICAXE act as a master controlling several additional ICs such as a memory chip and a digital sensor. However, i2c is a multi-master system and it is possible to have numerous controllers acting as masters at various points in a process. It is also possible to have ICs change roles during the process. These advanced setups will be beyond the scope of this tutorial, but it is important to understand that they are possible

There are two i2c implementations on PICAXE - software and hardware. The software implementation is available on all of the parts with i2c support - X, X1, and X2. Hardware i2c is only available on the X1 and X2 parts and the manual recommends using hardware i2c on those parts. When a PICAXE controller is acting as the master on an i2c bus there will be three relevant commands. The program must first execute a command which establishes some basic criteria about the slave device such as its unique address on the bus, and the speed at which the slave can operate. Once the slave device is established, the program will execute commands to either read or write to the slave device.

The principles of software and hardware implementation are essentially the same. However, there are different commands for each implementation and hardware i2c has some capabilities not available in software - notably the ability to act as a slave on the bus. The following chart should be of some use in understanding the protocols.

Software vs. Hardware Implementations

Software

Hardware

Function

I2CSLAVE

HI2CSETUP HI2CMASTER

Establishes the PICAXE as a master on the i2c bus and preparesto connect with a slave device.

n/a

HI2CSETUP I2CSLAVE

Establishes the PICAXE as a slave on the i2cbus.

n/a

HI2CSETUP OFF

Stops background i2c processing

WRITEI2C

HI2COUT

Writes a byte or sequence of bytes to the i2c device.

READI2C

HI2CIN

Reads a byte or sequence of bytes from the i2c device.

The syntax of the I2CSLAVE and HI2CSETUP HI2CMASTER commands are identical - they each take three parameters:

slaveaddress is the unique identifier of the slave device. It is generally listed in binary form such as %10100111. The least significant bit (the digit furthest to the right) is used for setting the mode to read or write. This digit doesn't actually doesn't matter in PICAXE BASIC as it is handled programmatically. You will sometimes see binary addresses in spec sheets written with an "x" in that location: %1010011x. Use either 1 or 0 when executing the command on PICAXE controllers.

mode refers to the speed of transfer and is expressed using the keywords i2cfast or i2cslow. The mode is dictated by the slowest device on the bus. When using hardware i2c, the i2cfast and i2cslow keywords can be additionally modified to account for increased clock speeds - i2cfast_8 (8 MHz), i2cfast_16 (16 MHz), i2cslow_8 (8 MHz), and i2cslow_16 (16 MHz)are all valid keywords.

addresslen refers to the size of address which is either byte (keyword i2cbyte) or word (keyword i2cword). Again, the addresslen parameter is a function of the device being accessed. The address length is frequently confused with the size of the data being transferred on the bus - i2c data is always transferred in byte increments regardless of whether the length of the address is a byte or a word (two bytes).

Once the required information to read and write from a slave device is established, the appropriate read and write commands can be executed. It is not necessary to execute additional I2CSLAVE or HI2CSETUP HI2CMASTER commands for every read or write. In software i2c a new I2CSLAVE command will need to be executed to change to a new slave address. In hardware i2c a new slave address can be entered as a parameter to the HI2COUT and HI2CIN commands.

When reading and writing to slave devices, the syntax for hardware and software implementation is again very similar, with the addition in hardware of the optional newslave parameter.

To read from an i2c device in software use the syntax:

READI2Clocation,(variable1, variable2 ...)

To write to an i2c device in software use the syntax:

WRITEI2Clocation,(variable1, variable2 ...)

Location is a optional variable or constant specifying an address on the slave device. The variables either receive the data read or contain the data to be written.

To read from an i2c device in hardware use the syntax:

HI2CIN[newslave],location,(variable1, variable2 ...)

To write to an i2c device in hardware use the syntax:

HI2COUT[newslave],location,(variable1, variable2 ...)

Both newslave and location variables are optional. Newslave is a new slave address for this (and all future) commands. Location is a variable or constant specifying an address on the slave device. The variables either receive the data read or contain the data to be written.

24LCxxx EEPROMs

The 24LCxxx EEPROMs are very commonly used. They are available in a variety of packages including the standard 8-pin DIP (dual inline pin) which makes them ideal for breadboard and home PCB assembly projects. A pinout diagram of the 24LCxxx DIP package is nearby.

Legs 1-3 (A0-A2) are used for setting the slave address on EEPROMs that support configurable addressing. All 24LCxxx EEPROMS have an address that begins %1010. If the EEPROM supports configurable addressing, then the A0-A2 pins are used to set the remaining three digits with A0 being the least significant (furthest to the right). If a pin is tied to ground then the digit is a zero, if the pin is tied to positive voltage then the digit is a one. If A0 were tied to positive voltage and the remaining pins tied to ground, then the address would be %1010001x

Leg 5 is the data line and leg 6 is the clock signal - these are the legs which are connected to the appropriate lines of the i2c bus. Each of the bus lines is pulled high by connecting it to positive voltage through a resistor. In typical configurations a 4.7k resistor is used, but there are times when a lower value may need to be substituted (on long bus runs for example).

Leg 7 is used for write protection. If it is tied high (connected to positive voltage) then writing to the chip is prevented, if it is tied low (connected to ground) then writing to the chip is enabled. A common configuration is to wire the pin directly to ground so that writing is always enabled. Sometimes the write protect pin is tied to an output of a PICAXE or other microcontroller in order to enable and disable writing programmatically.

The 24LC16B is a 16Kbit EEPROM organized as eight blocks of 256 x 8 bit memory - which means it will store 2048 bytes (2Kbyte) of data. The "B" series of EEPROMs are Microchip's least expensive, priced at less than $0.50 even in single quantities. A limitation of the 24LC16B and other EEPROMs with part numbers ending in "B" is that they use byte addressing which limits the internal address to 256 registers. This addressing protocol is only enough to address a single block of registers. To enable use of the full eight blocks, the 24LC16B borrows 3 of the 7 address bits from the slave address to specify the memory block and therefore the three address pins A0-A2 are not functional. The result of this limitation is that all 24LC16Bs have the same address and therefore only one chip can be used on an i2c bus. While it might seem like a small number, 2 kilobytes can often be more than enough for a project. A 24LC16B could hold two thousand sensor readings or 64 messages for a 2x16 LCD display.

When needed, the 24LC256 is a nice upgrade from the 24LC16B. The 24LC256 is a 256 Kbit (32 Kbyte) EEPROM. Like its smaller cousin it is inexpensive - less than $2.00 in single quantities and less than $1.00 in bulk. In addition to their greater capacity, the 24LC256 uses word length addressing. The configurable address lines are functional which allows up to eight devices to be included on the same bus.

When writing to either of these EEPROMS a short delay of about 10ms is necessary to complete the write cycle. It is typical to include a PAUSE 10 command after a write command to accomplish this delay. Both the 24LC16B and the 24LC256 have a page write buffer that enables multiple bytes to be written in a single operation. Use of the page buffer can dramatically improve speed and efficiency.

The 24LC16B has a 16 byte page buffer and the 24LC256 has a 64 byte page buffer. However, that does not mean that 16 or 64 bytes can always be written. Page write operations are limited to writing bytes within a single page. Page boundaries are a related to the address space of the device in question. They start at addresses that are multiples of the page size and end at addresses that are integer multiples the page size \96 1. Therefore on the 24LC16B with a 16 byte page, there is a page that starts at location 0 and ends at location 15, another page from 16 to 31, and another from 32 to 47, etc. Likewise on the 24LC256 with a 64 byte page, there is a page that starts at location 0 and ends at location 63, another page from 64 to 127, and another page from 128 to 191, etc.

If an HI2COUT or WRITEI2C command attempts to write across a page boundary, instead of being written to the next page the data wraps around to the beginning of the current page. Any data at the beginning of the page is overwritten. There is no warning of this overwriting, and depending on the type of data being written, it might not be immediately obvious the programming error has been made. Program code must be carefully written to prevent page write operations that would attempt to cross a page boundary.

About the Examples

The tutorial concludes with two example circuits, a PICAXE 18X with a 24LC16B, and a PICAXE 20X2 with two 24LC256 chips. The 18X is used to demonstrate software i2c implementation while the 20X2 will use the hardware commands. The pinouts of these two processors are shown below. The i2c data (sda) and clock (scl) pins on these processors are pre-defined - on the 18X they are on legs 7 and 10, while on the 20X2 they are on legs 13 and 11.

PICAXE 18X with a 24LC16B EEPROM

Pictured below is a basic schematic for a circuit interfacing a PICAXE 18X with a 24LC16B. Note in the circuit that the i2c lines are tied high with 4.7k resistors and that the write protect pin on the 24LC16B is tied low with a connection straight to ground.

This illustration shows how you might implement the circuit on a standard solderless breadboard.

Here is a little bit of sample code to show how you might apply software i2c commands to this circuit. This sample and the next both use a programming cable to send results to the terminal in the PICAXE Programming Editor. Those connections are not shown in the sample circuit.

PICAXE 20X2 with two 24LC256 EEPROMs

Pictured below is a basic schematic for a circuit interfacing a PICAXE 20X2 with two 24LC256 EEPROMS. This circuit is, of course, very similar to the prior example. Note that here there are connections to the address configuration lines to enable more than one 24LC256 to be present on the i2c bus. Also of interest is
the fact that only two pullup resistors are needed even when additional devices have been added to the circuit.

This illustration shows how you might implement the circuit on a standard solderless breadboard.

Here is a little bit of sample code to how you might apply hardware i2c commands to this circuit.