Struct stm32f4xx_hal::flash::UnlockedFlash

pub struct UnlockedFlash<'a> { /* private fields */ }

Result of FlashExt::unlocked()

Examples

use stm32f4xx_hal::pac::Peripherals;
use stm32f4xx_hal::flash::{FlashExt, LockedFlash, UnlockedFlash};
use embedded_storage::nor_flash::NorFlash;

let dp = Peripherals::take().unwrap();
let mut flash = LockedFlash::new(dp.FLASH);

// Unlock flash for writing
let mut unlocked_flash = flash.unlocked();

// Erase the second 128 KB sector.
NorFlash::erase(&mut unlocked_flash, 128 * 1024, 256 * 1024).unwrap();

// Write some data at the start of the second 128 KB sector.
let buf = [0u8; 64];
NorFlash::write(&mut unlocked_flash, 128 * 1024, &buf).unwrap();

// Lock flash by dropping
drop(unlocked_flash);

Implementations

impl UnlockedFlash<'_>

pub fn erase(&mut self, sector: u8) -> Result<(), Error>

Erase a flash sector

Refer to the reference manual to see which sector corresponds to which memory address.

pub fn program<'a, I>(&mut self, offset: usize, bytes: I) -> Result<(), Error> where
    I: Iterator<Item = &'a u8>, 

Program bytes with offset into flash memory, aligned to 128-bit rows

Trait Implementations

impl Drop for UnlockedFlash<'_>

Automatically lock flash erase/program when leaving scope

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> NorFlash for UnlockedFlash<'a>

const WRITE_SIZE: usize = 1usize

The minumum number of bytes the storage peripheral can write

const ERASE_SIZE: usize = 131_072usize

The minumum number of bytes the storage peripheral can erase

fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error>

Erase the given storage range, clearing all data within [from..to]. The given range will contain all 1s afterwards.

fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error>

If power is lost during write, the contents of the written words are undefined, but the rest of the page is guaranteed to be unchanged. It is not allowed to write to the same word twice. offset and bytes.len() must both be multiples of WRITE_SIZE.

impl<'a> ReadNorFlash for UnlockedFlash<'a>

type Error = Error

An enumeration of storage errors

const READ_SIZE: usize = 1usize

The minumum number of bytes the storage peripheral can read

fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error>

Read a slice of data from the storage peripheral, starting the read operation at the given address offset, and reading bytes.len() bytes.

fn capacity(&self) -> usize

The capacity of the peripheral in bytes.

impl<'a> MultiwriteNorFlash for UnlockedFlash<'a>