5 unstable releases

Uses old Rust 2015

0.3.0 Jan 20, 2019
0.2.1 Jan 20, 2019
0.2.0 Nov 22, 2018
0.1.1 Aug 22, 2018
0.1.0 Aug 18, 2018

#577 in Embedded development

Download history 24/week @ 2021-02-21 25/week @ 2021-02-28 18/week @ 2021-03-07 27/week @ 2021-03-14 35/week @ 2021-03-21 34/week @ 2021-03-28 56/week @ 2021-04-04 52/week @ 2021-04-11 86/week @ 2021-04-18 65/week @ 2021-04-25 78/week @ 2021-05-02 85/week @ 2021-05-09 1353/week @ 2021-05-16 38/week @ 2021-05-23 1190/week @ 2021-05-30 716/week @ 2021-06-06

225 downloads per month
Used in 3 crates (2 directly)

MIT/Apache

27KB
298 lines

Rust 24x EEPROM Driver

crates.io Docs Build Status Coverage Status Maintenance Intention

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.

Introductory blog post

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

To use this driver, import this crate and an embedded_hal implementation, then instantiate the appropriate device. In the following examples an instance of the device AT24C256 will be created as an example. Other devices can be created with similar methods like: Eeprom24x::new_24x64(...).

extern crate eeprom24x;
extern crate embedded_hal;
extern crate linux_embedded_hal;

use eeprom24x::{Eeprom24x, SlaveAddr};
use embedded_hal::blocking::delay::DelayMs;
use linux_embedded_hal::{Delay, I2cdev};

fn main() {
    let dev = I2cdev::new("/dev/i2c-1").unwrap();
    let address = SlaveAddr::default();
    let mut eeprom = Eeprom24x::new_24x256(dev, address);
    let memory_address = 0x1234;
    let data = 0xAB;

    eeprom.write_byte(memory_address, data).unwrap();

    Delay.delay_ms(5u16);

    let read_data = eeprom.read_byte(memory_address).unwrap();

    println!(
        "Read memory address: {}, retrieved content: {}",
        memory_address, &read_data
    );

    let _dev = eeprom.destroy(); // Get the I2C device back
}

License

Licensed under either of

Contributing

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~82KB