Struct eeprom24x::Eeprom24x

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

EEPROM24X driver

Implementations

impl<I2C, PS, AS, SN> Eeprom24x<I2C, PS, AS, SN>

Common methods

pub fn destroy(self) -> I2C

Destroy driver instance, return I²C bus instance.

impl<I2C, E, PS, AS, SN> Eeprom24x<I2C, PS, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

Common methods

pub fn write_byte(&mut self, address: u32, 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: u32) -> Result<u8, Error<E>>

Read a single byte from an address.

pub fn read_data( &mut self, address: u32, 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, AS, SN> Eeprom24x<I2C, PS, AS, SN>

where I2C: I2c<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, OneByte, No>

where I2C: I2c<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, OneByte, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B8, OneByte, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B8, OneByte, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx01 device (e.g. 24CS01)

impl<I2C, E> Eeprom24x<I2C, B8, OneByte, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx02 device (e.g. 24CS02)

impl<I2C, E> Eeprom24x<I2C, B8, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24x02E48 device (e.g. 24AA02E48)

impl<I2C, E> Eeprom24x<I2C, B8, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24x02E64 device (e.g. 24AA02E64)

impl<I2C, E, AS, SN> Eeprom24x<I2C, B8, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, OneByte, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx04 device (e.g. AT24CS04)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx08 device (e.g. AT24CS08)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx16 device (e.g. AT24CS16)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24x025E48 device (e.g. 24AA025E48)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24x025E64 device (e.g. 24AA025E64)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a M24C01 device (e.g. M24C01)

impl<I2C, E> Eeprom24x<I2C, B16, OneByte, No>

where I2C: I2c<Error = E>,

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

Create a new instance of a M24C02 device (e.g. M24C02)

impl<I2C, E, AS, SN> Eeprom24x<I2C, B16, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B32, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B32, TwoBytes, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx32 device (e.g. AT24CS32)

impl<I2C, E> Eeprom24x<I2C, B32, TwoBytes, Yes>

where I2C: I2c<Error = E>,

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

Create a new instance of a 24CSx64 device (e.g. AT24CS64)

impl<I2C, E, AS, SN> Eeprom24x<I2C, B32, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B64, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E, AS, SN> Eeprom24x<I2C, B64, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E, AS, SN> Eeprom24x<I2C, B128, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E> Eeprom24x<I2C, B256, TwoBytes, No>

where I2C: I2c<Error = E>,

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

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

impl<I2C, E, AS, SN> Eeprom24x<I2C, B256, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

pub fn write_page(&mut self, address: u32, 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 and its overall capacity. 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, PS, E> Eeprom24x<I2C, PS, OneByte, Yes>

where I2C: I2c<Error = E>,

Methods for interacting with the factory-programmed unique serial number for devices with one byte addresses. e.g. 24CSx01, 24CSx02,24CSx04, 24CSx08, and 24CSx16.

pub fn read_unique_serial(&mut self) -> Result<[u8; 16], Error<E>>

Read the 128-bit unique serial number.

impl<I2C, PS, E> Eeprom24x<I2C, PS, TwoBytes, Yes>

where I2C: I2c<Error = E>,

Methods for interacting with the factory-programmed unique serial number for devices with two byte addresses. e.g. 24CSx32 and 24CSx64

pub fn read_unique_serial(&mut self) -> Result<[u8; 16], Error<E>>

Read the 128-bit unique serial number.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B128, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B16, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B256, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B32, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B64, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size

impl<I2C, E, AS, SN> Eeprom24xTrait for Eeprom24x<I2C, B8, AS, SN>

where I2C: I2c<Error = E>, AS: MultiSizeAddr,

type Error = E

Inner implementation error.

fn write_byte( &mut self, address: u32, data: u8 ) -> Result<(), Error<Self::Error>>

Write a single byte in an address.

fn read_byte(&mut self, address: u32) -> Result<u8, Error<Self::Error>>

Read a single byte from an address.

fn read_data( &mut self, address: u32, data: &mut [u8] ) -> Result<(), Error<Self::Error>>

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

fn read_current_address(&mut self) -> Result<u8, Error<Self::Error>>

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

fn write_page( &mut self, address: u32, data: &[u8] ) -> Result<(), Error<Self::Error>>

Write up to a page starting in an address.

fn page_size(&self) -> usize

Return device page size