Struct eeprom24x::Eeprom24x

pub struct Eeprom24x<I2C, PS> { /* private fields */ }

EEPROM24X driver

Implementations

impl<I2C, E, PS> Eeprom24x<I2C, PS>where
    I2C: Write<Error = E> + WriteRead<Error = E>,

Common methods

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

pub fn write_byte(&mut self, address: [u8; 2], data: u8) -> Result<(), Error<E>>

Write a single byte in an address.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

pub fn read_byte(&mut self, address: [u8; 2]) -> Result<u8, Error<E>>

Read a single byte from an address.

pub fn read_data(
    &mut self,
    address: [u8; 2],
    data: &mut [u8]
) -> Result<(), Error<E>>

Read starting in an address as many bytes as necessary to fill the data array provided.

impl<I2C, E, PS> Eeprom24x<I2C, PS>where
    I2C: Read<Error = E>,

Specialization for platforms which implement embedded_hal::blocking::i2c::Read

pub fn read_current_address(&mut self) -> Result<u8, Error<E>>

Read the contents of the last address accessed during the last read or write operation, incremented by one.

Note: This may not be available on your platform.

impl<I2C, E> Eeprom24x<I2C, No>where
    I2C: Write<Error = E> + WriteRead<Error = E>,

Specialization for devices without page access (e.g. 24C00)

pub fn new_24x00(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x00 device (e.g. 24C00)

impl<I2C, E> Eeprom24x<I2C, B8>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 8 bytes.

pub fn new_24x01(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x01 device (e.g. AT24C01)

pub fn new_24x02(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x02 device (e.g. AT24C02)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

impl<I2C, E> Eeprom24x<I2C, B16>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 16 bytes.

pub fn new_24x04(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x04 device (e.g. AT24C04)

pub fn new_24x08(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x08 device (e.g. AT24C08)

pub fn new_24x16(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x16 device (e.g. AT24C16)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

impl<I2C, E> Eeprom24x<I2C, B32>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 32 bytes.

pub fn new_24x32(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x32 device (e.g. AT24C32)

pub fn new_24x64(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x64 device (e.g. AT24C64)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

impl<I2C, E> Eeprom24x<I2C, B64>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 64 bytes.

pub fn new_24x128(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x128 device (e.g. AT24C128)

pub fn new_24x256(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x256 device (e.g. AT24C256)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

impl<I2C, E> Eeprom24x<I2C, B128>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 128 bytes.

pub fn new_24x512(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24x512 device (e.g. AT24C512)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

impl<I2C, E> Eeprom24x<I2C, B256>where
    I2C: Write<Error = E>,

Specialization for devices with a page size of 256 bytes.

pub fn new_24xm01(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24xM01 device (e.g. AT24CM01)

pub fn new_24xm02(i2c: I2C, address: SlaveAddr) -> Self

Create a new instance of a 24xM02 device (e.g. AT24CM02)

pub fn write_page(
    &mut self,
    address: [u8; 2],
    data: &[u8]
) -> Result<(), Error<E>>

Write up to a page starting in an address.

The maximum amount of data that can be written depends on the page size of the device. If too much data is passed, the error Error::TooMuchData will be returned.

After writing a byte, the EEPROM enters an internally-timed write cycle to the nonvolatile memory. During this time all inputs are disabled and the EEPROM will not respond until the write is complete.

Trait Implementations

impl<I2C: Debug, PS: Debug> Debug for Eeprom24x<I2C, PS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I2C: Default, PS: Default> Default for Eeprom24x<I2C, PS>

fn default() -> Eeprom24x<I2C, PS>

Returns the “default value” for a type.