Embassy STM32

https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/
Admin
Embassy STM32 is a crate within the Embassy asynchronous embedded framework for Rust, providing...
Tokens:48,440
Snippets:255
Trust Score:8.2
Update:7 months ago
Show doc for...
Tokens:
Raw
### FlashRegion Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashRegion.html?search=u32+-%3E+bool

Provides methods to interact with the FlashRegion, such as getting the absolute base address, end address, and the number of sectors.

```APIDOC
## impl FlashRegion

### Methods
- **base(&self) -> u32**
  Returns the absolute base address of the flash region.
- **end(&self) -> u32**
  Returns the absolute end address of the flash region.
- **sectors(&self) -> u8**
  Returns the number of sectors within the flash region.
```

--------------------------------

### Implement FlashRegion Methods in Rust

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashRegion.html

Provides implementations for key methods of the `FlashRegion` struct in Rust. These methods include `base()` to get the absolute base address, `end()` to get the absolute end address, and `sectors()` to determine the number of sectors within the region.

```rust
impl FlashRegion {
    // ... other implementations

    /// Absolute base address.
    pub fn base(&self) -> u32 {
        // Implementation details...
        0
    }

    /// Absolute end address.
    pub fn end(&self) -> u32 {
        // Implementation details...
        0
    }

    /// Number of sectors in the region.
    pub const fn sectors(&self) -> u8 {
        // Implementation details...
        0
    }
}
```

--------------------------------

### FlashBank Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.FlashBank.html

Provides information on the implementations available for FlashBank, specifically the `base` function to get the absolute base address.

```APIDOC
## FlashBank Implementations

### impl FlashBank

#### pub fn base(&self) -> u32

##### Description
Absolute base address.

##### Method
GET

##### Endpoint
`/websites/embassy_dev_embassy-stm32_git_stm32c092kb_flash/flashbank/base`

##### Response

###### Success Response (200)
- **base_address** (u32) - The absolute base address of the FlashBank.
```

--------------------------------

### FlashRegion Details

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides detailed information about a specific flash memory region, including its name, start address, size, and page size.

```APIDOC
## GET /flash/regions/{region_name}

### Description
Retrieves detailed information for a specific STM32 flash memory region.

### Method
GET

### Endpoint
/flash/regions/{region_name}

### Parameters
#### Path Parameters
- **region_name** (string) - Required - The name of the flash region (e.g., "stm32l486zg").

### Request Example
```
GET /flash/regions/stm32l486zg
```

### Response
#### Success Response (200)
- **name** (string) - The name of the flash region.
- **start_address** (hex string) - The starting memory address of the flash region.
- **size** (integer) - The size of the flash region in bytes.
- **page_size** (integer) - The size of a flash page in bytes.

#### Response Example
```json
{
  "name": "stm32l486zg",
  "start_address": "0x08000000",
  "size": 1048576,
  "page_size": 2048
}
```

#### Error Response (404)
- **message** (string) - "Region not found."

```

--------------------------------

### Flash Memory Driver Overview

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/index.html?search=u32+-%3E+bool

Provides an overview of the flash memory driver's components, including data structures, enumerations, constants, and available functions for interacting with the internal flash memory.

```APIDOC
## Flash Memory Driver Overview

This section details the components of the STM32C092KB's internal flash memory driver.

### Structs

*   **Bank1Region**: Represents a region within Bank 1 of the flash memory.
*   **Flash**: The main driver structure for internal flash memory.
*   **FlashLayout**: Describes the layout of the flash memory.
*   **FlashRegion**: Defines a specific region within the flash memory.
*   **FlashSector**: Represents a single sector of the flash memory.

### Enums

*   **Async**: Enumeration for asynchronous flash mode typestate.
*   **Blocking**: Enumeration for blocking flash mode typestate.
*   **Error**: Enumeration for flash-related errors.
*   **FlashBank**: Enumeration representing different flash banks.

### Constants

*   **BANK1_REGION**: Constant defining a specific region in Bank 1.
*   **FLASH_BASE**: The base address of the flash memory.
*   **FLASH_REGIONS**: Represents the total number of flash regions.
*   **FLASH_SIZE**: The total size of the flash memory.
*   **MAX_ERASE_SIZE**: The maximum size of a block that can be erased.
*   **READ_SIZE**: The size of a single read operation (always 1).
*   **WRITE_SIZE**: The size of a single write operation.

### Functions

*   **get_flash_regions()**: Retrieves all defined flash memory regions.
```

--------------------------------

### FlashSector Struct

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashSector.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines a flash memory sector with its bank, index, start address, and size.

```APIDOC
## Struct FlashSector

### Description
Flash sector.

### Fields
- **bank** (FlashBank) - Bank number.
- **index_in_bank** (u8) - Sector number within the bank.
- **start** (u32) - Absolute start address.
- **size** (u32) - Size in bytes.

### Trait Implementations
- **Debug**: Formats the value using the given formatter.
- **Format**: Writes the defmt representation of `self` to `fmt`.
- **PartialEq**: Tests for `self` and `other` values to be equal.
- **StructuralPartialEq**: Structural partial equality comparison.
```

--------------------------------

### Flash Driver Initialization

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html?search=std%3A%3Avec

Provides methods for initializing the flash driver in blocking mode and splitting it into regions.

```APIDOC
## POST /flash/initialize

### Description
Initializes a new flash driver instance in blocking mode.

### Method
POST

### Endpoint
/flash/initialize

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **p** (Peri<'d, FLASH>) - Required - The FLASH peripheral to use.

### Request Example
```json
{
  "p": "FLASH_PERIPHERAL_INSTANCE"
}
```

### Response
#### Success Response (200)
- **FlashDriver** (Flash<'d, Blocking>) - The initialized blocking flash driver instance.

#### Response Example
```json
{
  "driver": "<flash_driver_instance>"
}
```

## POST /flash/regions

### Description
Splits an existing flash driver instance into one instance per flash memory region, usable in blocking mode.

### Method
POST

### Endpoint
/flash/regions

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **flash_driver** (Flash<'d, MODE>) - Required - The flash driver instance to split.

### Request Example
```json
{
  "flash_driver": "<flash_driver_instance>"
}
```

### Response
#### Success Response (200)
- **FlashLayout** (FlashLayout<'d, Blocking>) - A flash layout instance representing the memory regions.

#### Response Example
```json
{
  "layout": "<flash_layout_instance>"
}
```
```

--------------------------------

### Generic Type Conversions (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.FlashBank.html?search=u32+-%3E+bool

Demonstrates blanket implementations for common generic conversions like `Any`, `Borrow`, `CloneToUninit`, `From`, `Into`, `TryFrom`, and `TryInto`. These allow FlashBank and other types to interact seamlessly within generic contexts.

```rust
impl<T> Any for T where T: 'static + ?Sized
impl<T> Borrow<T> for T where T: ?Sized
impl<T> BorrowMut<T> for T where T: ?Sized
unsafe fn clone_to_uninit(&self, dest: *mut u8)
impl<T> From<T> for T
impl<T, U> Into<U> for T where U: From<T>
impl<T, U> TryFrom<U> for T where U: Into<T>
impl<T, U> TryInto<U> for T where U: TryFrom<T>
```

--------------------------------

### Get Flash Regions

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/fn.get_flash_regions.html?search=

Retrieves a list of all available flash memory regions. This is a read-only operation.

```APIDOC
## GET /websites/embassy_dev_embassy-stm32_git_stm32c092kb_flash/flash_regions

### Description
Retrieves a list of all available flash memory regions. This is a read-only operation.

### Method
GET

### Endpoint
/websites/embassy_dev_embassy-stm32_git_stm32c092kb_flash/flash_regions

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **flash_regions** (array of FlashRegion) - A list of flash memory regions.

##### FlashRegion Object
- **name** (string) - The name of the flash region.
- **start** (integer) - The starting address of the flash region.
- **end** (integer) - The ending address of the flash region.
- **len** (integer) - The length of the flash region.
- **is_bootloader** (boolean) - Indicates if the region is part of the bootloader.
- **is_application** (boolean) - Indicates if the region is part of the application.
- **is_storage** (boolean) - Indicates if the region is used for storage.
- **is_config** (boolean) - Indicates if the region is used for configuration.

#### Response Example
```json
{
  "flash_regions": [
    {
      "name": "bootloader",
      "start": 0,
      "end": 16383,
      "len": 16384,
      "is_bootloader": true,
      "is_application": false,
      "is_storage": false,
      "is_config": false
    },
    {
      "name": "application",
      "start": 16384,
      "end": 131071,
      "len": 114688,
      "is_bootloader": false,
      "is_application": true,
      "is_storage": false,
      "is_config": false
    }
  ]
}
```
```

--------------------------------

### Rust: Implement Borrow<T> for T

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Demonstrates the blanket implementation of `Borrow<T>` for `T` itself. This allows any type to be borrowed immutably as itself.

```rust
impl<T> Borrow<T> for T
where T: ?Sized
```

--------------------------------

### Generic Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Blocking.html?search=

Details blanket implementations of generic traits like `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`.

```APIDOC
## Generic Trait Blanket Implementations

### Description
This section outlines blanket implementations for common Rust traits that apply generically to types, including those related to the flash memory API.

### Method
N/A (Trait Implementations)

### Endpoint
N/A (Trait Implementations)

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Trait Implementations:

*   **`impl<T> Any for T where T: 'static + ?Sized`**
    *   **`fn type_id(&self) -> TypeId`**: Gets the `TypeId` of `self`.

*   **`impl<T> Borrow<T> for T where T: ?Sized`**
    *   **`fn borrow(&self) -> &T`**: Immutably borrows from an owned value.

*   **`impl<T> BorrowMut<T> for T where T: ?Sized`**
    *   **`fn borrow_mut(&mut self) -> &mut T`**: Mutably borrows from an owned value.

*   **`impl<T> From<T> for T`**
    *   **`fn from(t: T) -> T`**: Returns the argument unchanged.

*   **`impl<T, U> Into<U> for T where U: From<T>`**
    *   **`fn into(self) -> U`**: Calls `U::from(self)`.

*   **`impl<T, U> TryFrom<U> for T where U: Into<T>`**
    *   **`type Error = Infallible`**: The type returned in the event of a conversion error.
    *   **`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`**: Performs the conversion.

*   **`impl<T, U> TryInto<U> for T where U: TryFrom<T>`**
    *   **`type Error = <U as TryFrom<T>>::Error`**: The type returned in the event of a conversion error.
    *   **`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`**: Performs the conversion.

```

--------------------------------

### Generic Implementations for FlashRegion in Rust

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashRegion.html

Demonstrates various blanket and generic trait implementations for the `FlashRegion` struct in Rust. These include implementations for `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`, enabling broader interoperability and type conversions.

```rust
// Example for Any trait
impl<T: 'static + ?Sized> Any for T {
    fn type_id(&self) -> TypeId {
        // Implementation details...
        TypeId::of::<T>()
    }
}

// Example for Borrow trait
impl<T: ?Sized> Borrow<T> for T {
    fn borrow(&self) -> &T {
        // Implementation details...
        self
    }
}

// Example for From trait
impl<T> From<T> for T {
    fn from(t: T) -> T {
        // Implementation details...
        t
    }
}

// Example for TryFrom trait
use std::convert::Infallible;
impl<T, U> TryFrom<U> for T where U: Into<T> {
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, Self::Error> {
        // Implementation details...
        Ok(value.into())
    }
}
```

--------------------------------

### Blocking Write Operation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs a blocking write operation to the flash memory. The offset is relative to the flash start address.

```APIDOC
## POST /flash/bank1/write

### Description
Performs a blocking write operation to the flash memory. The offset is relative to the flash start address. It is not allowed to write to the same word twice.

### Method
POST

### Endpoint
/flash/bank1/write

### Parameters
#### Query Parameters
- **offset** (u32) - Required - The offset from the flash start address.
- **bytes** (&[u8]) - Required - A byte slice containing the data to write.

### Request Body
```json
{
  "offset": 0x1000,
  "bytes": [1, 2, 3, 4, 5, 6, 7, 8]
}
```

### Response
#### Success Response (200)
- **Result** (Result<(), Error>) - Indicates success or failure of the write operation.

#### Response Example
```json
{
  "result": "Ok(())"
}
```
```

--------------------------------

### Blocking Read Operation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs a blocking read operation from the flash memory. The offset is relative to the flash start address.

```APIDOC
## POST /flash/bank1/read

### Description
Performs a blocking read operation from the flash memory. The offset is relative to the flash start address.

### Method
POST

### Endpoint
/flash/bank1/read

### Parameters
#### Query Parameters
- **offset** (u32) - Required - The offset from the flash start address.
- **bytes** (&mut [u8]) - Required - A mutable byte slice to store the read data.

### Request Body
```json
{
  "offset": 0x1000,
  "bytes": null 
}
```

### Response
#### Success Response (200)
- **Result** (Result<(), Error>) - Indicates success or failure of the read operation.

#### Response Example
```json
{
  "result": "Ok(())"
}
```
```

--------------------------------

### Rust: Implement From and Into Traits for Generic Types

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=u32+-%3E+bool

Demonstrates blanket implementations for `From<T>` for `T` and `Into<U>` for `T` where `U` implements `From<T>`. These traits provide idiomatic ways to perform type conversions in Rust.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T {
        t
    }
}

impl<T, U>
    Into<U>
    for T
where
    U: From<T>,
{
    fn into(self) -> U {
        U::from(self)
    }
}
```

--------------------------------

### Get Type ID of Any Type (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.FlashBank.html

Implements the `Any` trait for any type `T` that is `'static`. The `type_id` method returns the unique `TypeId` of the instance.

```rust
impl<T> Any for T where T: 'static + ?Sized
fn type_id(&self) -> TypeId
```

--------------------------------

### TryFrom and TryInto Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Details the blanket implementations of `TryFrom` and `TryInto` traits for fallible type conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T
where U: Into<T>

### Description
This is a blanket implementation of the `TryFrom` trait. It allows a type `T` to attempt conversion from a type `U`, provided `U` implements `Into<T>`. This conversion can fail.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Types
#### type Error = Infallible

##### Description
The type returned in the event of a conversion error. `Infallible` indicates that this specific blanket implementation does not produce errors.

### Associated Functions
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

##### Description
Performs the conversion. For this blanket implementation, it's expected to always succeed if `U: Into<T>` holds.

##### Parameters
- **value** (U) - The value to attempt to convert.

##### Return Type
`Result<T, <T as TryFrom<U>>::Error>` - A `Result` containing the converted value `T` or an error.

##### Example
```rust
// Example where U: Into<T> is true and conversion is infallible
let number = 5;
let result: Result<i32, std::convert::Infallible> = i32::try_from(number);
match result {
    Ok(val) => println!("Successfully converted: {}", val),
    Err(_) => println!("Conversion failed"),
}
```

## impl<T, U> TryInto<U> for T
where U: TryFrom<T>

### Description
This is a blanket implementation of the `TryInto` trait. It allows a type `T` to attempt conversion into a type `U`, provided `U` implements `TryFrom<T>`. This conversion can fail.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Types
#### type Error = <U as TryFrom<T>>::Error

##### Description
The type returned in the event of a conversion error, as defined by the `TryFrom<T>` implementation for `U`.

### Associated Functions
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

##### Description
Performs the conversion. This method delegates to `U::try_from(self)`.

##### Parameters
- **self** (T) - The value to attempt to convert.

##### Return Type
`Result<U, <U as TryFrom<T>>::Error>` - A `Result` containing the converted value `U` or an error.

##### Example
```rust
// Assuming a struct `MyInt` and `i32` where `MyInt` can be tried into `i32`
struct MyInt(i32);
impl TryFrom<MyInt> for i32 {
    type Error = String;
    fn try_from(value: MyInt) -> Result<Self, Self::Error> {
        if value.0 >= 0 {
            Ok(value.0)
        } else {
            Err(String::from("Negative number cannot be converted"))
        }
    }
}

let positive_my_int = MyInt(10);
match positive_my_int.try_into() {
    Ok(val) => println!("Successfully converted: {}", val),
    Err(e) => println!("Conversion failed: {}", e),
}

let negative_my_int = MyInt(-5);
match negative_my_int.try_into() {
    Ok(val) => println!("Successfully converted: {}", val),
    Err(e) => println!("Conversion failed: {}", e),
}
```
```

--------------------------------

### Flash Driver Structure and Initialization (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html

Defines the generic Flash driver structure and provides a constructor for creating a blocking mode instance. It requires a peripheral handle for the FLASH controller.

```rust
pub struct Flash<'d, MODE = Async> { /* private fields */ }

impl<'d> Flash<'d, Blocking> {
    pub fn new_blocking(p: Peri<'d, FLASH>) -> Self {
        // ... implementation ...
    }
}
```

--------------------------------

### Blocking Erase Operation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=std%3A%3Avec

Performs a blocking erase operation on a specified range of flash memory. The offsets are relative to the start of the flash.

```APIDOC
## POST /flash/erase

### Description
Performs a blocking erase operation on a specified range of flash memory. The offsets are relative to the start of the flash, not absolute addresses.

### Method
POST

### Endpoint
/flash/erase

### Parameters
#### Request Body
- **from** (u32) - Required - The starting offset from the flash start address for the erase operation.
- **to** (u32) - Required - The ending offset from the flash start address for the erase operation.

### Request Example
```json
{
  "from": 0x1000,
  "to": 0x2000
}
```

### Response
#### Success Response (200)
- **None** - Indicates the erase operation was successful.

#### Error Response (e.g., 500)
- **Error** - An enum representing potential errors during the operation.
```

--------------------------------

### Blocking Write Operation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=std%3A%3Avec

Performs a blocking write operation to the flash memory. The offset is relative to the start of the flash, not an absolute address.

```APIDOC
## POST /flash/write

### Description
Performs a blocking write operation to the flash memory. The offset is relative to the start of the flash, not an absolute address.

### Method
POST

### Endpoint
/flash/write

### Parameters
#### Request Body
- **offset** (u32) - Required - The offset from the flash start address to begin writing.
- **bytes** (array of u8) - Required - A byte slice containing the data to write to flash.

### Request Example
```json
{
  "offset": 0x1000,
  "bytes": [1, 2, 3, 4]
}
```

### Response
#### Success Response (200)
- **None** - Indicates the write operation was successful.

#### Error Response (e.g., 500)
- **Error** - An enum representing potential errors during the operation.
```

--------------------------------

### From and Into Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Covers the blanket implementations of `From` and `Into` traits, facilitating type conversions.

```APIDOC
## impl<T> From<T> for T

### Description
This is a blanket implementation of the `From` trait. It states that a type `T` can be converted from itself. This is a trivial conversion.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Functions
#### fn from(t: T) -> T

##### Description
Returns the argument unchanged. This is the implementation for `T` converting from `T`.

##### Parameters
- **t** (T) - The value to convert.

##### Return Type
T - The original value.

##### Example
```rust
let original_value = 5;
let converted_value = i32::from(original_value);
assert_eq!(original_value, converted_value);
```

## impl<T, U> Into<U> for T
where U: From<T>

### Description
This is a blanket implementation of the `Into` trait. It allows a type `T` to be converted into a type `U` if `U` implements `From<T>`.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Functions
#### fn into(self) -> U

##### Description
Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

##### Parameters
- **self** (T) - The value to convert.

##### Return Type
U - The converted value.

##### Example
```rust
struct MyInt(i32);
impl From<i32> for MyInt {
    fn from(item: i32) -> Self {
        MyInt(item)
    }
}

let number = 10;
let my_int: MyInt = number.into(); // Uses the Into trait
assert_eq!(my_int.0, 10);
```
```

--------------------------------

### Blocking Read Operation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=std%3A%3Avec

Performs a blocking read operation from the flash memory. The offset is relative to the start of the flash, not an absolute address.

```APIDOC
## POST /flash/read

### Description
Performs a blocking read operation from the flash memory. The offset is relative to the start of the flash, not an absolute address.

### Method
POST

### Endpoint
/flash/read

### Parameters
#### Request Body
- **offset** (u32) - Required - The offset from the flash start address to begin reading.
- **bytes** (array of u8) - Required - A mutable byte slice to store the data read from flash.

### Request Example
```json
{
  "offset": 0x1000,
  "bytes": [0, 0, 0, 0] 
}
```

### Response
#### Success Response (200)
- **None** - Indicates the read operation was successful.

#### Error Response (e.g., 500)
- **Error** - An enum representing potential errors during the operation.
```

--------------------------------

### Borrow and BorrowMut Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Documentation for the blanket implementations of `Borrow` and `BorrowMut` traits, allowing immutable and mutable borrowing respectively.

```APIDOC
## impl<T> Borrow<T> for T

### Description
This is a blanket implementation of the `Borrow` trait for any type `T`. It allows a type to be immutably borrowed as a reference to itself.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Functions
#### fn borrow(&self) -> &T

##### Description
Immutably borrows from an owned value. This method is part of the `Borrow` trait.

##### Parameters
N/A

##### Return Type
`&T` - An immutable reference to the value.

##### Example
```rust
let value = 5;
let borrowed_value: &i32 = (&value as &dyn std::borrow::Borrow<i32>).borrow();
println!("Borrowed value: {}", borrowed_value);
```

## impl<T> BorrowMut<T> for T

### Description
This is a blanket implementation of the `BorrowMut` trait for any type `T`. It allows a type to be mutably borrowed as a mutable reference to itself.

### Method
N/A (Blanket Implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Associated Functions
#### fn borrow_mut(&mut self) -> &mut T

##### Description
Mutably borrows from an owned value. This method is part of the `BorrowMut` trait.

##### Parameters
N/A

##### Return Type
`&mut T` - A mutable reference to the value.

##### Example
```rust
let mut value = 5;
let borrowed_mut_value: &mut i32 = (&mut value as &mut dyn std::borrow::BorrowMut<i32>).borrow_mut();
*borrowed_mut_value += 1;
println!("Modified value: {}", value);
```
```

--------------------------------

### Generic Blanket Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashLayout.html?search=

Showcases blanket implementations for common traits applied to any type T. These include Any, Borrow, BorrowMut, From, Into, TryFrom, and TryInto, providing fundamental type conversions and capabilities.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}
impl<T> Borrow<T> for T where T: ?Sized {
    fn borrow(&self) -> &T
}
impl<T> BorrowMut<T> for T where T: ?Sized {
    fn borrow_mut(&mut self) -> &mut T
}
impl<T> From<T> for T {
    fn from(t: T) -> T
}
impl<T, U> Into<U> for T where U: From<T> {
    fn into(self) -> U
}
impl<T, U> TryFrom<U> for T where U: Into<T> {
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}
impl<T, U> TryInto<U> for T where U: TryFrom<T> {
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### ReadNorFlash Trait: Read Implementation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the `read` method for the `ReadNorFlash` trait. Reads a specified number of bytes from the flash memory starting at a given offset.

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

--------------------------------

### Initialize Blocking Flash Driver

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new flash driver instance configured for blocking operations. It takes a `Peri<'d, FLASH>` peripheral as input, representing the flash memory interface.

```rust
pub fn new_blocking(p: Peri<'d, FLASH>) -> Self
```

--------------------------------

### Implement Generic Traits for FlashSector in Rust

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashSector.html?search=std%3A%3Avec

Demonstrates the implementation of several common generic traits for the FlashSector struct in Rust, including Any, Borrow, BorrowMut, From, Into, TryFrom, and TryInto. These implementations enable various forms of type manipulation and conversion.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId
}
```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
{
    fn borrow(&self) -> &T
}
```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
{
    fn borrow_mut(&mut self) -> &mut T
}
```

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T
}
```

```rust
impl<T, U> Into<U> for T
where U: From<T>,
{
    fn into(self) -> U
}
```

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}
```

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### Get Flash Regions

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/fn.get_flash_regions.html?search=std%3A%3Avec

Retrieves a list of all available flash memory regions. This endpoint is useful for understanding the memory layout and available storage segments.

```APIDOC
## GET /flash/regions

### Description
Retrieves a list of all available flash memory regions.

### Method
GET

### Endpoint
/flash/regions

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **regions** (array of objects) - A list of flash region objects.
  - **name** (string) - The name of the flash region.
  - **start_address** (integer) - The starting memory address of the region.
  - **size** (integer) - The size of the flash region in bytes.

#### Response Example
```json
{
  "regions": [
    {
      "name": "BOOTLOADER",
      "start_address": 131072,
      "size": 16384
    },
    {
      "name": "APPLICATION",
      "start_address": 163840,
      "size": 114688
    }
  ]
}
```
```

--------------------------------

### Rust: Implement From<T> for T

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Shows the trivial blanket implementation of `From<T>` for `T`. This allows a type to be converted into itself using `T::from(value)`.

```rust
impl<T> From<T> for T
```

--------------------------------

### Blocking Write to Flash Memory (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=u32+-%3E+bool

Performs a blocking write operation to the flash memory. The offset is relative to the flash start. This function writes a slice of bytes to the flash.

```rust
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error>
```

--------------------------------

### Rust Generic Implementation: Any Trait

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html

This generic implementation allows any type T that is 'static and sized to implement the Any trait. It provides a method to get the TypeId of the implementing type, useful for runtime type information.

```rust
impl<T> Any for T
where
    T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId {
        // Implementation details omitted for brevity
    }
}
```

--------------------------------

### Rust: Implement TryFrom<U> for T

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Explains the blanket implementation of `TryFrom<U>` for `T` where `U` implements `Into<T>`. This provides a fallible conversion from `U` to `T`.

```rust
impl<T, U>
where U: Into<T>
TryFrom<U> for T
```

--------------------------------

### NOR Flash Trait Implementations (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html

Implements the `NorFlash` and `ReadNorFlash` traits for the Flash driver. Defines constants for write and erase sizes, and provides methods for reading, writing, erasing, and getting capacity.

```rust
impl<MODE> NorFlash for Flash<'_, MODE> {
    const WRITE_SIZE: usize = 8;
    const ERASE_SIZE: usize = 2_048;

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

    fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
        // ... implementation ...
    }
}

impl<MODE> ReadNorFlash for Flash<'_, MODE> {
    const READ_SIZE: usize = 1;

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

    fn capacity(&self) -> usize {
        // ... implementation ...
    }
}
```

--------------------------------

### Rust: Implement Send for Async

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Demonstrates the implementation of the `Send` trait for an `Async` type. The `Send` trait indicates that a type can be safely transferred between threads.

```rust
impl Send for Async
```

--------------------------------

### Blocking Flash Erase Operation (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html

Performs a blocking erase operation on a range of flash memory. The `from` and `to` parameters are offsets relative to the flash start. The specified range will be filled with ones after the operation.

```rust
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error> {
    // ... implementation ...
}
```

--------------------------------

### FlashBank Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.FlashBank.html

Details the various trait implementations for FlashBank, including Clone, Debug, PartialEq, Copy, and others.

```APIDOC
## FlashBank Trait Implementations

### impl Clone for FlashBank

#### fn clone(&self) -> FlashBank

##### Description
Returns a duplicate of the value.

### impl Clone for FlashBank

#### fn clone_from(&mut self, source: &Self)

##### Description
Performs copy-assignment from `source`.

### impl Debug for FlashBank

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

##### Description
Formats the value using the given formatter.

### impl Format for FlashBank

#### fn format(&self, f: Formatter<'_>)

##### Description
Writes the defmt representation of `self` to `fmt`.

### impl PartialEq for FlashBank

#### fn eq(&self, other: &FlashBank) -> bool

##### Description
Tests for `self` and `other` values to be equal, and is used by `==`.

### impl PartialEq for FlashBank

#### fn ne(&self, other: &Rhs) -> bool

##### Description
Tests for `!=`.

### impl Copy for FlashBank

### impl StructuralPartialEq for FlashBank
```

--------------------------------

### Blocking Write to STM32 Flash Memory

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=

Performs a blocking write operation to the specified flash memory region. The offset is relative to the flash start address. It is not allowed to write to the same word twice.

```rust
impl Bank1Region<'_, Blocking> {
    /// Blocking write.
    ///
    /// NOTE: `offset` is an offset from the flash start, NOT an absolute address. For example, to write address `0x0800_1234` you have to use offset `0x1234`.
    pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error>
}
```

--------------------------------

### FlashLayout Auto-Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashLayout.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the auto-trait implementations for the FlashLayout struct. These implementations automatically derive common traits like Freeze, RefUnwindSafe, Send, Sync, and Unpin, simplifying its usage in concurrent and safe Rust code.

```rust
impl<'d, MODE> Freeze for FlashLayout<'d, MODE>
impl<'d, MODE> RefUnwindSafe for FlashLayout<'d, MODE> where MODE: RefUnwindSafe
impl<'d, MODE> Send for FlashLayout<'d, MODE> where MODE: Send
impl<'d, MODE> Sync for FlashLayout<'d, MODE> where MODE: Sync
impl<'d, MODE> Unpin for FlashLayout<'d, MODE> where MODE: Unpin
impl<'d, MODE = Async> !UnwindSafe for FlashLayout<'d, MODE>
```

--------------------------------

### FlashLayout Auto-Trait Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashLayout.html?search=

Demonstrates the auto-trait implementations for the FlashLayout struct. These include Freeze, RefUnwindSafe, Send, Sync, Unpin, and a negative implementation for UnwindSafe when MODE is Async.

```rust
impl<'d, MODE> Freeze for FlashLayout<'d, MODE>
impl<'d, MODE> RefUnwindSafe for FlashLayout<'d, MODE>
where
    MODE: RefUnwindSafe,
impl<'d, MODE> Send for FlashLayout<'d, MODE>
where
    MODE: Send,
impl<'d, MODE> Sync for FlashLayout<'d, MODE>
where
    MODE: Sync,
impl<'d, MODE> Unpin for FlashLayout<'d, MODE>
where
    MODE: Unpin,
impl<'d, MODE = Async> !UnwindSafe for FlashLayout<'d, MODE>
```

--------------------------------

### ReadNorFlash Trait Implementation for STM32 Flash

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html

Implements the `ReadNorFlash` trait for the STM32 flash memory, defining the read size and providing methods for reading data and getting the device capacity. The `READ_SIZE` is 1 byte.

```rust
const READ_SIZE: usize = 1usize
fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error>
fn capacity(&self) -> usize
```

--------------------------------

### Rust Blanket Implementations: TryFrom and TryInto Traits

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Blocking.html?search=u32+-%3E+bool

Explains the blanket implementations for `TryFrom<U>` for `T` and `TryInto<U>` for `T` where `U: TryFrom<T>`. These provide fallible type conversions.

```rust
impl<T, U> TryFrom<U> for T
where
    U: Into<T>,

impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
```

--------------------------------

### NOR Flash Read Operation (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=std%3A%3Avec

Implements the `read` method for the `NorFlash` trait. This function reads a slice of data from the flash memory starting at a given offset. The minimum read size is 1 byte.

```rust
impl<MODE> ReadNorFlash for Bank1Region<'_, MODE> {
    const READ_SIZE: usize = 1usize;
    /// Read a slice of data from the storage peripheral, starting the read operation at the given address offset, and reading `bytes.len()` bytes. Read more
    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error>
}
```

--------------------------------

### Blocking Read from Flash Memory (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=u32+-%3E+bool

Performs a blocking read operation from the flash memory. The offset is relative to the flash start. This function reads a specified number of bytes into a mutable byte slice.

```rust
pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error>
```

--------------------------------

### Rust: Implement BorrowMut<T> for T

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Illustrates the blanket implementation of `BorrowMut<T>` for `T` itself. This enables mutable borrowing of a type as itself.

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized
```

--------------------------------

### Implement PartialEq for FlashSector in Rust

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashSector.html

Provides implementations for 'PartialEq' (equality comparison) for the 'FlashSector' struct in Rust. This includes methods for checking if two 'FlashSector' instances are equal ('eq') or not equal ('ne').

```rust
impl PartialEq for FlashSector {
    fn eq(&self, other: &FlashSector) -> bool {
        // Implementation details for equality check
    }
    fn ne(&self, other: &Rhs) -> bool {
        // Implementation details for inequality check
    }
}
```

--------------------------------

### Blocking Erase of Flash Memory Range (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=u32+-%3E+bool

Performs a blocking erase operation on a specified range of flash memory. Both `from` and `to` are offsets relative to the flash start. This function erases all data within the given range.

```rust
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error>
```

--------------------------------

### Blocking Read from STM32 Flash Memory

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Bank1Region.html?search=

Performs a blocking read operation from the specified flash memory region. The offset is relative to the flash start address. This function is part of the `Bank1Region` implementation for reading NOR flash.

```rust
impl<MODE> Bank1Region<'_, MODE> {
    /// Blocking read.
    ///
    /// NOTE: `offset` is an offset from the flash start, NOT an absolute address. For example, to read address `0x0800_1234` you have to use offset `0x1234`.
    pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error>
}
```

--------------------------------

### Implement Generic TryInto for T (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashSector.html?search=

Illustrates a blanket implementation of the `TryInto` trait for a type `T` into a target type `U`, where `U` implements `TryFrom<T>`. This offers a fallible conversion method, returning a `Result` to manage conversion outcomes.

```rust
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### Get Flash Regions (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/fn.get_flash_regions.html?search=

Retrieves all available flash memory regions. This function returns a static slice of `FlashRegion` structs, providing information about the memory layout. No specific dependencies are mentioned beyond the standard library.

```rust
pub fn get_flash_regions() -> &'static [&'static FlashRegion]
```

--------------------------------

### Generic Type Conversions (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.FlashBank.html

Demonstrates blanket implementations for common generic conversion traits: `From<T>` for `T`, `Into<U>` for `T` where `U: From<T>`, and `TryFrom<U>`/`TryInto<U>` for conversions that may fail.

```rust
impl<T> From<T> for T
impl<T, U> Into<U> for T where U: From<T>
impl<T, U> TryFrom<U> for T where U: Into<T>
impl<T, U> TryInto<U> for T where U: TryFrom<T>
```

--------------------------------

### Blocking Flash Write Operation (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html

Performs a blocking write operation to the flash memory. The `offset` is relative to the start of the flash. Writes a slice of bytes to the specified offset. It's not allowed to write to the same word twice.

```rust
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error> {
    // ... implementation ...
}
```

--------------------------------

### Blocking Flash Read Operation (Rust)

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html

Performs a blocking read operation from the flash memory. The `offset` is relative to the start of the flash, not an absolute memory address. Reads a specified number of bytes into a mutable byte slice.

```rust
pub fn blocking_read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Error> {
    // ... implementation ...
}
```

--------------------------------

### Rust: Implement TryInto<U> for T

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/enum.Async.html?search=

Covers the blanket implementation of `TryInto<U>` for `T` where `U` implements `TryFrom<T>`. This allows for fallible conversion from `T` to `U` using the `.try_into()` method.

```rust
impl<T, U>
where U: TryFrom<T>
TryInto<U> for T
```
Tokens:
Raw