Struct SpiFlash

pub struct SpiFlash<'a, SPI: Spi<'a>> {
    spi: SPI,
    cs: fn(active: bool),
    pub manufacturer: Manufacturer,
    pub size: FlashSize,
    pub page_count: u32,
    pub sector_count: u32,
    pub block_count: u32,
    four_byte_addr: bool,
    busy: bool,
    _phantom: PhantomData<&'a ()>,
}

Flash device configuration/handle.

Fields

spi: SPI

cs: fn(active: bool)

manufacturer: Manufacturer

size: FlashSize

page_count: u32

sector_count: u32

block_count: u32

four_byte_addr: bool

busy: bool

_phantom: PhantomData<&'a ()>

Implementations

impl<'a, SPI: Spi<'a>> SpiFlash<'a, SPI>

pub fn new(spi: SPI, cs: fn(active: bool)) -> Self

fn select(&self)

Pull CS low

fn deselect(&self)

Pull CS high

fn cmd( &mut self, cmd: u8, addr: Option<u32>, tx_data: Option<&[u8]>, rx_data: Option<&mut [u8]>, ) -> Result<(), i32>

Send command and optional address/data; optionally read.

pub fn find_chip(&mut self) -> Result<(), i32>

fn write_enable(&mut self) -> Result<(), i32>

fn write_disable(&mut self) -> Result<(), i32>

fn read_status(&mut self) -> Result<u8, i32>

pub fn wait_ready( &mut self, timeout: u32, delay: impl FnMut(u32), ) -> Result<(), i32>

pub fn erase_chip(&mut self, delay: impl FnMut(u32)) -> Result<(), i32>

pub fn erase_sector( &mut self, sector: u32, delay: impl FnMut(u32), ) -> Result<(), i32>

pub fn erase_block( &mut self, block: u32, delay: impl FnMut(u32), ) -> Result<(), i32>

pub fn write_address( &mut self, address: u32, data: &[u8], delay: impl FnMut(u32), ) -> Result<(), i32>

Write array to address, splits across pages as needed.

pub fn write_page( &mut self, page: u32, data: &[u8], offset: usize, delay: &mut impl FnMut(u32), ) -> Result<(), i32>

Write a partial page (up to 256-offset).

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

Read array from arbitrary address, splits if needed.

pub fn read_page( &mut self, page: u32, data: &mut [u8], offset: usize, ) -> Result<(), i32>

Read portion of a page

pub fn write_sector( &mut self, sector: u32, data: &[u8], offset: usize, delay: impl FnMut(u32), ) -> Result<(), i32>

pub fn read_sector( &mut self, sector: u32, data: &mut [u8], offset: usize, ) -> Result<(), i32>

pub fn write_block( &mut self, block: u32, data: &[u8], offset: usize, delay: impl FnMut(u32), ) -> Result<(), i32>

pub fn read_block( &mut self, block: u32, data: &mut [u8], offset: usize, ) -> Result<(), i32>

pub fn is_busy(&self) -> bool