Struct Eeprom

pub struct Eeprom<'a, I2C> {
    i2c: I2C,
    config: EepromConfig,
    busy: bool,
    _phantom: PhantomData<&'a ()>,
}

EEPROM driver handle

Fields

i2c: I2C

config: EepromConfig

busy: bool

_phantom: PhantomData<&'a ()>

Implementations

impl<'a, I2C> Eeprom<'a, I2C>

where I2C: I2c<'a>,

pub fn new(i2c: I2C, config: EepromConfig) -> Result<Self, EepromError>

Create a new EEPROM driver instance

pub fn is_device_ready(&mut self) -> Result<(), EepromError>

Check if the EEPROM device is ready

pub fn read(&mut self, address: u32, data: &mut [u8]) -> Result<(), EepromError>

Read data from EEPROM

pub fn write(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write data to EEPROM

fn write_pages(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write data with page boundary handling

fn write_chunk(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write a single chunk (within page boundary)

fn read_with_8bit_address( &mut self, address: u32, data: &mut [u8], ) -> Result<(), EepromError>

Read with 8-bit addressing

fn read_with_16bit_address( &mut self, address: u32, data: &mut [u8], ) -> Result<(), EepromError>

Read with 16-bit addressing

fn read_4kbit( &mut self, address: u32, data: &mut [u8], ) -> Result<(), EepromError>

Read from 4Kbit EEPROM (uses device address bits)

fn read_8kbit( &mut self, address: u32, data: &mut [u8], ) -> Result<(), EepromError>

Read from 8Kbit EEPROM (uses device address bits)

fn read_16kbit( &mut self, address: u32, data: &mut [u8], ) -> Result<(), EepromError>

Read from 16Kbit EEPROM (uses device address bits)

fn write_with_8bit_address( &mut self, address: u32, data: &[u8], ) -> Result<(), EepromError>

Write with 8-bit addressing

fn write_with_16bit_address( &mut self, address: u32, data: &[u8], ) -> Result<(), EepromError>

Write with 16-bit addressing

fn write_4kbit(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write to 4Kbit EEPROM

fn write_8kbit(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write to 8Kbit EEPROM

fn write_16kbit(&mut self, address: u32, data: &[u8]) -> Result<(), EepromError>

Write to 16Kbit EEPROM

fn delay_ms(&self, _ms: u32)

Simple delay function - in real implementation, this would use the system timer

pub fn config(&self) -> &EepromConfig

Get the EEPROM configuration

pub fn is_busy(&self) -> bool

Check if the driver is busy

impl<'a, I2C> Eeprom<'a, I2C>

where I2C: I2c<'a>,

Convenience functions for common operations

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

Read a single byte

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

Write a single byte

pub fn read_u16(&mut self, address: u32) -> Result<u16, EepromError>

Read a u16 value (big-endian)

pub fn write_u16(&mut self, address: u32, data: u16) -> Result<(), EepromError>

Write a u16 value (big-endian)

pub fn read_u32(&mut self, address: u32) -> Result<u32, EepromError>

Read a u32 value (big-endian)

pub fn write_u32(&mut self, address: u32, data: u32) -> Result<(), EepromError>

Write a u32 value (big-endian)

pub fn clear_range( &mut self, start_address: u32, length: u32, ) -> Result<(), EepromError>

Clear (fill with 0xFF) a range of EEPROM