Expand description
This is a platform agnostic Rust driver for the 24x series serial EEPROM,
based on the embedded-hal
traits.
This driver allows you to:
- Read a single byte from a memory address. See
read_byte()
. - Read a byte array starting on a memory address. See:
read_data()
. - Read the current memory address (please read notes). See:
read_current_address()
. - Write a byte to a memory address. See:
write_byte()
. - Write a byte array (up to a memory page) to a memory address. See:
write_page()
.
Can be used at least with the devices listed below.
The devices
These devices provides a number of bits of serial electrically erasable and programmable read only memory (EEPROM) organized as a number of words of 8 bits each. The devices’ cascadable feature allows up to 8 devices to share a common 2-wire bus. The devices are optimized for use in many industrial and commercial applications where low power and low voltage operation are essential.
Device | Memory bits | 8-bit words | Page size | Datasheet |
---|---|---|---|---|
24x00 | 128 bits | 16 | N/A | 24C00 |
24x01 | 1 Kbit | 128 | 8 bytes | AT24C01 |
24x02 | 2 Kbit | 256 | 8 bytes | AT24C02 |
24x04 | 4 Kbit | 512 | 16 bytes | AT24C04 |
24x08 | 8 Kbit | 1,024 | 16 bytes | AT24C08 |
24x16 | 16 Kbit | 2,048 | 16 bytes | AT24C16 |
24x32 | 32 Kbit | 4,096 | 32 bytes | AT24C32 |
24x64 | 64 Kbit | 8,192 | 32 bytes | AT24C64 |
24x128 | 128 Kbit | 16,384 | 64 bytes | AT24C128 |
24x256 | 256 Kbit | 32,768 | 64 bytes | AT24C256 |
24x512 | 512 Kbit | 65,536 | 128 bytes | AT24C512 |
24xM01 | 1 Mbit | 131,072 | 256 bytes | AT24CM01 |
24xM02 | 2 Mbit | 262,144 | 256 bytes | AT24CM02 |
Usage examples (see also examples folder)
To create a new instance you can use the new_<device>
methods.
There are many compatible vendors so the method has a somewhat generic name.
For example, if you are using an AT24C32, you can create a device by calling
Eeprom24x::new_24x32(...)
.
Please refer to the device table above for more examples.
Instantiating with the default address
Import this crate and an embedded_hal
implementation, then instantiate
the device:
extern crate linux_embedded_hal as hal;
extern crate eeprom24x;
use hal::I2cdev;
use eeprom24x::{ Eeprom24x, SlaveAddr };
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
// using the AT24C256
let mut eeprom = Eeprom24x::new_24x256(dev, address);
Providing an alternative address
extern crate linux_embedded_hal as hal;
extern crate eeprom24x;
use hal::I2cdev;
use eeprom24x::{ Eeprom24x, SlaveAddr };
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let (a2, a1, a0) = (false, false, true);
let address = SlaveAddr::Alternative(a2, a1, a0);
let mut eeprom = Eeprom24x::new_24x256(dev, address);
Writting and reading a byte
extern crate linux_embedded_hal as hal;
extern crate eeprom24x;
use hal::I2cdev;
use eeprom24x::{ Eeprom24x, SlaveAddr };
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut eeprom = Eeprom24x::new_24x256(dev, SlaveAddr::default());
let address = [0x12, 0x34];
let data = 0xAB;
eeprom.write_byte(address, data);
// EEPROM enters internally-timed write cycle. Will not respond for some time.
let retrieved_data = eeprom.read_byte(address);
Writting a page
extern crate linux_embedded_hal as hal;
extern crate eeprom24x;
use hal::I2cdev;
use eeprom24x::{ Eeprom24x, SlaveAddr };
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut eeprom = Eeprom24x::new_24x256(dev, SlaveAddr::default());
let address = [0x12, 0x34];
let data = [0xAB; 64];
eeprom.write_page(address, &data);
// EEPROM enters internally-timed write cycle. Will not respond for some time.