STM32CubeF1

https://github.com/stmicroelectronics/stm32cubef1
Admin
The STM32CubeF1 MCU Package provides a comprehensive embedded software platform for the STM32F1...
Tokens:1,703,397
Snippets:14,308
Trust Score:9.8
Update:5 days ago
Show doc for...
Tokens:
Raw
### osMailCreate Example Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__Mail.html

Example showing the inclusion of cmsis_os.h, thread ID definitions, and a custom mail object structure.

```c
#include "cmsis_os.h"

osThreadId tid_thread1; // ID for thread 1

osThreadId tid_thread2; // ID for thread 2

typedef struct { // Mail object structure

float voltage; // AD result of measured voltage

float current; // AD result of measured current

int counter; // A counter value

} T_MEAS;
```

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

### Flash Driver Setup and Usage Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__flash__interface__gr.html

A complete example demonstrating the initialization, power control, data reading, and uninitialization of a Flash device using the CMSIS-RTOS2 framework.

```c
#include "Driver_Flash.h"
#include "cmsis_os2.h" // ARM::CMSIS:RTOS2:Keil RTX5

/* Flash driver instance */
extern ARM_DRIVER_FLASH Driver_Flash0;

static ARM_DRIVER_FLASH * flashDev = &Driver_Flash0;

/* CMSIS-RTOS2 Thread Id */
osThreadId_t Flash_Thread_Id;

/* Flash signal event */
void Flash_Callback(uint32_t event)
{
if (event & ARM_FLASH_EVENT_READY) {
/* The read/program/erase operation is completed */
osThreadFlagsSet(Flash_Thread_Id, 1U);
}
if (event & ARM_FLASH_EVENT_ERROR) {
/* The read/program/erase operation is completed with errors */
/* Call debugger or replace with custom error handling */
__breakpoint(0);
}
}

/* CMSIS-RTOS2 Thread */
void Flash_Thread (void *argument)
{
/* Query drivers capabilities */
const ARM_FLASH_CAPABILITIES capabilities = flashDev->GetCapabilities();

/* Initialize Flash device */
if (capabilities.event_ready) {
flashDev->Initialize (&Flash_Callback);
} else {
flashDev->Initialize (NULL);
}

/* Power-on Flash device */
flashDev->PowerControl (ARM_POWER_FULL);

/* Read data taking data_width into account */
uint8_t buf[256U];
flashDev->ReadData (0x1000U, buf, sizeof(buf)>>capabilities.data_width);

/* Wait operation to be completed */
if (capabilities.event_ready) {
osThreadFlagsWait (1U, osFlagsWaitAny, 100U);
} else {
osDelay(100U);
}

/* Switch off gracefully */
flashDev->PowerControl (ARM_POWER_OFF);
flashDev->Uninitialize ();
}
```

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

### Variance Calculation Example Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/DSP/html/arm_variance_example_f32_8c-example.html

Initializes the necessary buffers and test input data for the floating-point variance calculation example.

```c
#include <math.h>
#include "arm_math.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */
#define MAX_BLOCKSIZE 32
#define DELTA (0.000001f)

/* ----------------------------------------------------------------------
* Declare I/O buffers
* ------------------------------------------------------------------- */
float32_t wire1[MAX_BLOCKSIZE];
float32_t wire2[MAX_BLOCKSIZE];
float32_t wire3[MAX_BLOCKSIZE];

/* ----------------------------------------------------------------------
* Test input data for Floating point Variance example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */
float32_t testInput_f32[32] =
{
-0.432564811528221, -1.665584378238097, 0.125332306474831, 0.287676420358549,
-1.146471350681464, 1.190915465642999, 1.189164201652103, -0.037633276593318,
0.327292361408654, 0.174639142820925, -0.186708577681439, 0.725790548293303,
```

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

### Initializing and Starting the RTOS Kernel

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

This example demonstrates the standard workflow within the main function: initializing the kernel, setting up peripherals or threads, and finally starting the kernel to begin thread switching.

```c
int main (void) {

osKernelInitialize (); // initialize CMSIS-RTOS

// initialize peripherals here

// create 'thread' functions that start executing,

// example: tid_name = osThreadCreate (osThread(name), NULL);

osKernelStart (); // start thread execution

}
```

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

### Initialize and start the RTOS scheduler in main

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/CMSIS_RTOS_Tutorial.pdf

Example of initializing the kernel, performing custom C code, creating threads, and starting the RTOS scheduler within the main function.

```C
void main (void) { osKernelInitialize (); IODIR1 = 0x00FF0000; // Do any C code you want Init_Thread(); //Create a Thread osKernelStart(); //Start the RTOS }
```

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

### Setup Transfer

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__mci__interface__gr.html

Example of setting up a data transfer and reading a sector from the memory card.

```c
volatile uint32_t MCI_Events;

void MCI_SignalEvent_Callback (uint32_t event) {

MCI_Events |= event; // Save current event

}

void read_sector ([ARM_DRIVER_MCI](group__mci__interface__gr.html#structARM__DRIVER__MCI) *drv, uint8_t *buf, uint32_t sz) {

int32_t status;

uint32_t cmd, arg;

uint32_t resp;

if (sz < 512U) {

// Invalid buffer size, sector consists of 512 bytes

//...

}

status = drv->[SetupTransfer](group__mci__interface__gr.html#adc63bab660e8304d78faa1ac429e792b) (buf, 1U, 512U, [ARM_MCI_TRANSFER_READ](group__mci__transfer__ctrls.html#gaa6f3be235a9dce5c66be8fe64f399846) | [ARM_MCI_TRANSFER_BLOCK](group__mci__transfer__ctrls.html#ga4ced782e7c0c70d5f0edbddd1e48323b));

if (status == [ARM_DRIVER_OK](group__execution__status.html#ga85752c5de59e8adeb001e35ff5be6be7)) {

MCI_Events = 0U; //Clear MCI driver event flags

cmd = 17U; // Set READ_SINGLE_BLOCK command

arg = 0U; // Set sector number

status = drv->[SendCommand](group__mci__interface__gr.html#affefb5c1d352082933c2fb0620b37212) (cmd, arg, [ARM_MCI_RESPONSE_SHORT](group__mci__send__command__flags__ctrls.html#gaa5ddf1cf772b234e3c247039effd0e7b) | [ARM_MCI_RESPONSE_CRC](group__mci__send__command__flags__ctrls.html#ga6ab3f4c1a2bf0fdb81fbcf7a5698f2de) | [ARM_MCI_TRANSFER_DATA](group__mci__send__command__flags__ctrls.html#ga8aa566f69aa74ed416213df6ca3267bd), &resp);

if (status == [ARM_DRIVER_OK](group__execution__status.html#ga85752c5de59e8adeb001e35ff5be6be7)) {

/* Wait for event */

while ((MCI_Events & [ARM_MCI_EVENT_COMMAND_COMPLETE](group__mci__event__gr.html#gae69356c75d55103d93ef91ac1bc02b49)) == 0U);

// Command was successfully sent to memory card

if ((resp & 0x03U) == 0U) {

// Sector number is valid, wait until data transfer completes

while ((MCI_Events & [ARM_MCI_EVENT_TRANSFER_COMPLETE](group__mci__event__gr.html#gabc3c468dedaed890683360f2c5c65bea)) == 0U);

// Data was successfully read from memory card

// ...

}

}

}

}
```

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

### Floating-point Dot Product Example Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/DSP/html/arm_dotproduct_example_f32_8c-example.html

Includes necessary headers and defines the block size and tolerance for the dot product calculation.

```c
#include <math.h>
#include "arm_math.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */
#define MAX_BLOCKSIZE 32
#define DELTA (0.000001f)
```

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

### Flash Driver Usage Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__flash__interface__gr.html

Example code demonstrating the typical setup and usage of the Flash driver, including initialization, power control, read operation, and event handling.

```APIDOC
## Flash Driver Usage Example

### Description
This example shows how to initialize and use the Flash driver, including querying capabilities, setting up callbacks, powering on, reading data, and handling events.

### Code
```c
#include "Driver_Flash.h"
#include "cmsis_os2.h" // ARM::CMSIS:RTOS2:Keil RTX5

/* Flash driver instance */
extern ARM_DRIVER_FLASH Driver_Flash0;
static ARM_DRIVER_FLASH * flashDev = &Driver_Flash0;

/* CMSIS-RTOS2 Thread Id */
osThreadId_t Flash_Thread_Id;

/* Flash signal event */
void Flash_Callback(uint32_t event)
{
  if (event & ARM_FLASH_EVENT_READY) {
    /* The read/program/erase operation is completed */
    osThreadFlagsSet(Flash_Thread_Id, 1U);
  }
  if (event & ARM_FLASH_EVENT_ERROR) {
    /* The read/program/erase operation is completed with errors */
    /* Call debugger or replace with custom error handling */
    __breakpoint(0);
  }
}

/* CMSIS-RTOS2 Thread */
void Flash_Thread (void *argument)
{
  /* Query drivers capabilities */
  const ARM_FLASH_CAPABILITIES capabilities = flashDev->GetCapabilities();

  /* Initialize Flash device */
  if (capabilities.event_ready) {
    flashDev->Initialize (&Flash_Callback);
  } else {
    flashDev->Initialize (NULL);
  }

  /* Power-on Flash device */
  flashDev->PowerControl (ARM_POWER_FULL);

  /* Read data taking data_width into account */
  uint8_t buf[256U];
  flashDev->ReadData (0x1000U, buf, sizeof(buf)>>capabilities.data_width);

  /* Wait operation to be completed */
  if (capabilities.event_ready) {
    osThreadFlagsWait (1U, osFlagsWaitAny, 100U);
  } else {
    osDelay(100U);
  }

  /* Switch off gracefully */
  flashDev->PowerControl (ARM_POWER_OFF);
  flashDev->Uninitialize ();
}
```
```

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

### Sine and Cosine Calculation Example Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/DSP/html/arm_sin_cos_example_f32_8c-example.html

This snippet includes the required headers, defines the block size and delta for testing, and provides the input data array for the sine and cosine calculation example.

```c
#include <math.h>
#include "arm_math.h"

/* ----------------------------------------------------------------------
* Defines each of the tests performed
* ------------------------------------------------------------------- */
#define MAX_BLOCKSIZE 32
#define DELTA (0.0001f)

/* ----------------------------------------------------------------------
* Test input data for Floating point sin_cos example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */
const float32_t testInput_f32[MAX_BLOCKSIZE] =
{
-1.244916875853235400, -4.793533929171324800, 0.360705030233248850, 0.827929644170887320, -3.299532218312426900, 3.427441903227623800, 3.422401784294607700, -0.108308165334010680,
0.941943896490312180, 0.502609575000365850, -0.537345278736373500, 2.088817392965764500, -1.693168684143455700, 6.283185307179590700, -0.392545884746175080, 0.327893095115825040,
3.070147440456292300, 0.170611405884662230, -0.275275082396073010, -2.395492805446796300, 0.847311163536506600, -3.845517018083148800, 2.055818378415868300, 4.672594161978930800,
-1.990923030266425800, 2.469305197656249500, 3.609002606064021000, -4.586736582331667500, -4.147080139136136300, 1.643756718868359500, -1.150866392366494800, 1.985805026477433800
};

const float32_t testRefOutput_f32 = 1.000000000;
```

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

### Example: Initialize MAC and PHY, set interface and mode

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__phy__interface__gr.html

Shows how to get the MAC capabilities, set the PHY interface, and set the PHY mode using ARM_ETH_PHY_SPEED_100M, ARM_ETH_PHY_DUPLEX_FULL, and ARM_ETH_PHY_ISOLATE. Error handling is indicated with comments.

```c
static ARM_ETH_MAC_CAPABILITIES capabilities;

static ARM_DRIVER_ETH_MAC *mac;

static ARM_DRIVER_ETH_PHY *phy;

mac = &Driver_ETH_MAC0;

phy = &Driver_ETH_PHY0;

// Initialize Media Access Controller

capabilities = mac->GetCapabilities ();

...

status = phy->SetInterface (capabilities.media_interface);

if (status != ARM_DRIVER_OK) ... // error handling

status = phy->SetMode (ARM_ETH_PHY_SPEED_100M | ARM_ETH_PHY_DUPLEX_FULL | ARM_ETH_PHY_ISOLATE);

if (status != ARM_DRIVER_OK) ... // error handling
```

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

### I2C Slave Mode Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Example of setting up the I2C interface in slave mode.

```c
#include "Driver_I2C.h"

/* I2C driver instance */

extern ARM_DRIVER_I2C Driver_I2C0;

static ARM_DRIVER_I2C *I2Cdrv = &Driver_I2C0;

static volatile uint32_t I2C_Event;

/* I2C Signal Event function callback */

static void I2C_SignalEvent (uint32_t event) {

I2C_Event |= event;

}

int main (void) {

uint8_t cnt = 0;

/* Initialize I2C peripheral */

I2Cdrv->Initialize(I2C_SignalEvent);

/* Power-on I2C peripheral */

I2Cdrv->PowerControl(ARM_POWER_FULL);

/* Configure I2C bus */
```

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

### Example: Set Ethernet PHY Interface and Mode

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__phy__interface__gr.html

Shows how to initialize the MAC, get its capabilities, set the PHY interface to the MAC's media interface, and set the PHY mode to auto-negotiate. Error handling is indicated with ellipses.

```c
static ARM_ETH_MAC_CAPABILITIES capabilities;

static ARM_DRIVER_ETH_MAC *mac;

static ARM_DRIVER_ETH_PHY *phy;

mac = &Driver_ETH_MAC0;

phy = &Driver_ETH_PHY0;

// Initialize Media Access Controller

capabilities = mac->GetCapabilities ();

...

status = phy->SetInterface (capabilities.media_interface);

if (status != ARM_DRIVER_OK) ... // error handling

status = phy->SetMode (ARM_ETH_PHY_AUTO_NEGOTIATE);

if (status != ARM_DRIVER_OK) ... // error handling

...
```

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

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbd__interface__gr.html

Demonstrates how to retrieve the driver's capabilities using the ARM_USBD_GetCapabilities function.

```c
extern ARM_DRIVER_USBD Driver_USBD0;

ARM_DRIVER_USBD *drv_info;

void read_capabilities (void) {

ARM_USBD_CAPABILITIES drv_capabilities;

drv_info = &Driver_USBD0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### osTimerStop usage example in C

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Example showing how to create a periodic timer, start it, stop it with osTimerStop, check the return status, and restart it. Includes the required cmsis_os.h include and timer callback prototype.

```C
#include "cmsis_os.h"

void Timer_Callback (void const *arg); // prototype for timer callback function

osTimerDef (Timer, Timer_Callback); // define timer

void TimerStop_example (void) {

  osTimerId id; // timer id
  osStatus status; // function return status

  // Create periodic timer
  exec = 1;
  id = osTimerCreate (osTimer(Timer2), osTimerPeriodic, NULL);

  osTimerStart (id, 1000); // start timer
  :
  status = osTimerStop (id); // stop timer
  if (status != osOK) {
    // Timer could not be stopped
  }
  :
  osTimerStart (id, 1000); // start timer again
  :
}
```

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

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbd__interface__gr.html

Demonstrates how to retrieve and verify the driver version using the ARM_USBD_GetVersion function.

```c
extern ARM_DRIVER_USBD Driver_USBD0;

ARM_DRIVER_USBD *drv_info;

void setup_usbd (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_USBD0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

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

### Linear Interpolation Example Setup

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/DSP/html/arm_linear_interp_example_f32_8c-example.html

Includes necessary headers and defines constants for the linear interpolation test, including the signal-to-noise ratio threshold and test sample length.

```c
#include "arm_math.h"
#include "math_helper.h"

#define SNR_THRESHOLD 90
#define TEST_LENGTH_SAMPLES 10
#define XSPACING (0.00005f)
```

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

### Initialize RTX Kernel and Configure Interrupt Priority

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS2/html/cre_rtx_proj.html

Example showing the initialization of the RTX kernel, setting the NVIC priority grouping, creating a thread, and starting the kernel.

```c
osKernelInitialize(); // initialize RTX

NVIC_SetPriorityGrouping (3); // setup priority grouping

tread_id = osThreadNew(tread_func, NULL, NULL); // create some threads

osKernelStart (); // start RTX kernel
```

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

### Add example project to PDSC <examples> section

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Pack/html/createPack_DFP.html

XML snippet to add an example project named 'Dummy' to the <examples> section of the PDSC file. It references a board, a project environment (uv), and a category attribute.

```XML
<examples>
  <example name="Dummy" doc="Abstract.txt" folder="Examples/dummy">
    <description>Dummy project</description>
    <board name="MVCM3 Starter Kit" vendor="MyVendor"/>
    <project>
      <environment name="uv" load="dummy.uvprojx"/>
    </project>
    <attributes>
      <category>Getting Started</category>
    </attributes>
  </example>
</examples>
```

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

### Start CMSIS-RTOS Kernel

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows the workflow for initializing the kernel and starting thread execution once the kernel is ready.

```c
int main (void) {

// System Initialization

SystemCoreClockUpdate();

// ...

if(osKernelGetState() == osKernelInactive) {

osKernelInitialize();

}

; // ... Start Threads

if (osKernelGetState() == osKernelReady) { // If kernel is ready to run...

osKernelStart(); // ... start thread execution

}

while(1); // only reached in case of error

}
```

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

### osTimerStart example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Example showing how to start a periodic timer using osTimerStart. The timer callback is defined, the timer is created with a periodic type and an argument, and then started with a delay. The status is checked for osOK.

```C
#include "cmsis_os.h"

void Time_Callback (void const *arg) { // timer callback function
  // arg contains &exec
  // called every second after osTimerStart
}

osTimerDef (Timer, Time_Callback); // define timer

uint32_t exec; // argument for the timer call back function

void TimerStart_example (void) {

  osTimerId id; // timer id
  uint32_t timerDelay; // timer value
  osStatus status; // function return status

  // Create periodic timer
  exec = 1;
  id = osTimerCreate (osTimer(Timer), osTimerPeriodic, &exec);
  if (id) {
    timerDelay = 1000;
    status = osTimerStart (id, timerDelay); // start timer
    if (status != osOK) {
      // Timer could not be started
    }
  }
  :
}
```

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

### Event Flags Get Name Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__EventFlags.html

Example showing the declaration of a variable to hold the event flags object ID for use with the osEventFlagsGetName function.

```c
void EvtFlagsGetName_example (void) {

char id; // id of the event flags object
```

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

### osTimerDelete example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Example showing how to delete a periodic timer using osTimerDelete. The timer is created with osTimerCreate and started with osTimerStart, then deleted. The status is checked for osOK.

```C
#include "cmsis_os.h"

void Timer_Callback (void const *arg); // prototype for timer callback function

osTimerDef (Timer, Timer_Callback); // define timer

void TimerDelete_example (void) {

  osTimerId id; // timer id
  osStatus status; // function return status

  // Create periodic timer
  exec = 1;
  id = osTimerCreate (osTimer(Timer2), osTimerPeriodic, NULL);
  osTimerStart (id, 1000UL); // start timer
  :
  status = osTimerDelete (id); // stop and delete timer
  if (status != osOK) {
    // Timer could not be deleted
  }
  :
}
```

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

### Example MPU Configuration

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Core/html/group__mpu__functions.html

Demonstrates setting up a memory region, enabling the MPU, and disabling it after executing protected code.

```c
void main()
{
// Set Region 0
ARM_MPU_SetRegionEx(0UL, 0x08000000UL, MPU_RASR(0UL, ARM_MPU_AP_FULL, 0UL, 0UL, 1UL, 1UL, 0x00UL, ARM_MPU_REGION_SIZE_1MB));
ARM_MPU_Enable(0);
// Execute application code that is access protected by the MPU
ARM_MPU_Disable();
}
```

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

### NAND Flash Driver Implementation Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__nand__interface__gr.html

This example demonstrates how to initialize a NAND device, configure power settings based on device capabilities, set bus parameters, and send a reset command.

```c
#include "Driver_NAND.h"

/* ONFI commands */

#define ONFI_CMD_READ_1ST 0x00 ///< Read 1st Cycle

#define ONFI_CMD_PROGRAM_2ND 0x10 ///< Page Program 2nd Cycle

#define ONFI_CMD_READ_2ND 0x30 ///< Read 2nd Cycle

#define ONFI_CMD_PROGRAM_1ST 0x80 ///< Page Program 1st Cycle

#define ONFI_CMD_RESET 0xFF ///< Reset Command

/* NAND Signal Event callback function */

volatile uint32_t NAND_Events;

void NAND_SignalEventCallback (uint32_t dev_num, uint32_t event) {

if (dev_num == 0) {

NAND_Events |= event;

}

else {

// ..

}

}

/* NAND device Power ON */

void PowerOn (ARM_DRIVER_NAND *drv, uint32_t dev_num) {

ARM_NAND_CAPABILITIES capabilities;

// Query drivers capabilities

capabilities = drv->GetCapabilities();

// Initialize NAND device

drv->Initialize (NAND_SignalEventCallback);

// Power-on NAND driver

drv->PowerControl (ARM_POWER_FULL);

// Turn ON device power

uint32_t volt = 0U;

if (capabilities.vcc) { volt |= ARM_NAND_POWER_VCC_3V3; }

if (capabilities.vcc_1v8) { volt |= ARM_NAND_POWER_VCC_1V8; }

if (capabilities.vccq) { volt |= ARM_NAND_POWER_VCCQ_3V3; }

if (capabilities.vccq_1v8) { volt |= ARM_NAND_POWER_VCCQ_1V8; }

if (volt != 0U) {

drv->DevicePower (volt);

}

// Setting bus mode

drv->Control (0U, ARM_NAND_BUS_MODE, ARM_NAND_BUS_SDR);

// Setting bus data width

drv->Control (0U, ARM_NAND_BUS_DATA_WIDTH, ARM_NAND_BUS_DATA_WIDTH_8);

// Enable chip manually if needed

if (capabilities.ce_manual) {

drv->ChipEnable (dev_num, true);

}

// Send ONFI Reset command */

drv->SendCommand (dev_num, ONFI_CMD_RESET);

}

/* NAND device Power OFF */
```

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

### Middleware Initialization with Driver Instances

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/theoryOperation.html

Example showing how to pass specific driver instances to middleware functions.

```c
void init_middleware (ARM_DRIVER_SPI *Drv_spi) ...

\\ inside the middleware the SPI driver functions are called with:

\\ Drv_spi->function (...);

\\ setup middleware

init_middleware (&Driver_SPI1); // connect middleware to SPI1 interface

:

init_middleware (&Driver_SPI2); // connect middleware to SPI2 interface
```

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

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Demonstrates how to retrieve the driver capabilities using the ARM_I2C_GetCapabilities function.

```c
extern ARM_DRIVER_I2C Driver_I2C0;

ARM_DRIVER_I2C *drv_info;

void read_capabilities (void) {

ARM_I2C_CAPABILITIES drv_capabilities;

drv_info = &Driver_I2C0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### Enable MPU with configuration

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Core/html/group__mpu__functions.html

Examples of enabling the MPU with different control settings.

```c
// enable MPU with all region definitions. Exceptions are not protected by MPU.

MPU_Enable (0);

// enable MPU with all region definitions and background regions for privileged access. Exceptions are protected by MPU.

MPU_Enable (MPU_CTRL_PRIVDEFENA_Msk | MPU_CTRL_HFNMIENA_Msk);
```

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

### Application Main Thread and Kernel Initialization

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Example demonstrating the initialization of the system clock, optional event recorder, CMSIS-RTOS kernel, and the creation of the application main thread.

```c
/*----------------------------------------------------------------------------
 * Application main thread
 *---------------------------------------------------------------------------*/
void app_main (void *argument) {
  // ...
  for (;;) {}
}

int main (void) {
  // System Initialization
  SystemCoreClockUpdate();

#ifdef RTE_Compiler_EventRecorder
  // Initialize and start Event Recorder
  EventRecorderInitialize(EventRecordError, 1U);
#endif

  // ...
  osKernelInitialize(); // Initialize CMSIS-RTOS
  osThreadNew(app_main, NULL, NULL); // Create application main thread
  osKernelStart(); // Start thread execution
  for (;;) {}
}
```

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

### SPI Interface Usage Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__spi__interface__gr.html

This example demonstrates initializing the SPI driver, configuring power, and setting up a callback function to handle SPI events like transfer completion or errors.

```c
#include "Driver_SPI.h"

#include "cmsis_os.h" // ARM::CMSIS:RTOS:Keil RTX

void mySPI_Thread(void const *argument);

osThreadId tid_mySPI_Thread;

/* SPI Driver */

extern ARM_DRIVER_SPI Driver_SPI0;

void mySPI_callback(uint32_t event)

{

switch (event)

{

case ARM_SPI_EVENT_TRANSFER_COMPLETE:

/* Success: Wakeup Thread */

osSignalSet(tid_mySPI_Thread, 0x01);

break;

case ARM_SPI_EVENT_DATA_LOST:

/* Occurs in slave mode when data is requested/sent by master

but send/receive/transfer operation has not been started

and indicates that data is lost. Occurs also in master mode

when driver cannot transfer data fast enough. */

__breakpoint(0); /* Error: Call debugger or replace with custom error handling */

break;

case ARM_SPI_EVENT_MODE_FAULT:

/* Occurs in master mode when Slave Select is deactivated and

indicates Master Mode Fault. */

__breakpoint(0); /* Error: Call debugger or replace with custom error handling */

break;

}

}

/* Test data buffers */

const uint8_t testdata_out[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };

uint8_t testdata_in [8];

void mySPI_Thread(void const* arg)

{

ARM_DRIVER_SPI* SPIdrv = &Driver_SPI0;

osEvent evt;

#ifdef DEBUG

ARM_DRIVER_VERSION version;

ARM_SPI_CAPABILITIES drv_capabilities;

version = SPIdrv->GetVersion();

if (version.api < 0x200) /* requires at minimum API version 2.00 or higher */

{ /* error handling */

return;

}

drv_capabilities = SPIdrv->GetCapabilities();

if (drv_capabilities.event_mode_fault == 0)

{ /* error handling */

return;

}

#endif

/* Initialize the SPI driver */

SPIdrv->Initialize(mySPI_callback);

/* Power up the SPI peripheral */

SPIdrv->PowerControl(ARM_POWER_FULL);

/* Configure the SPI to Master, 8-bit mode @10000 kBits/sec */
```

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

### Get Driver Capabilities Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usart__interface__gr.html

Demonstrates how to retrieve the capabilities of the USART driver using the ARM_USART_GetCapabilities function.

```c
extern ARM_DRIVER_USART Driver_USART0;

ARM_DRIVER_USART *drv_info;

void read_capabilities (void) {

ARM_USART_CAPABILITIES drv_capabilities;

drv_info = &Driver_USART0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### SystemInit

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Core_A/html/system__ARMCA9_8h.html

Initializes the system and updates the SystemCoreClock variable.

```APIDOC
## SystemInit

### Description
Initializes the system and updates the SystemCoreClock variable.

### Function Signature
void SystemInit(void)

### Parameters
None

### Return Value
None
```

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

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usart__interface__gr.html

Demonstrates how to retrieve and verify the driver version using the ARM_USART_GetVersion function.

```c
extern ARM_DRIVER_USART Driver_USART0;

ARM_DRIVER_USART *drv_info;

void setup_usart (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_USART0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

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

### ARM_ETH_MAC_GetCapabilities Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__mac__interface__gr.html

Demonstrates how to retrieve driver capabilities using the ARM_ETH_MAC_GetCapabilities function.

```c
extern ARM_DRIVER_ETH_MAC Driver_ETH_MAC0;

ARM_DRIVER_ETH_MAC *mac;

void read_capabilities (void) {

ARM_ETH_MAC_CAPABILITIES mac_capabilities;

mac = &Driver_ETH_MAC0;

mac_capabilities = mac->GetCapabilities ();

// interrogate capabilities

}
```

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

### Get Driver Version Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__i2c__interface__gr.html

Demonstrates how to retrieve and verify the driver version using the ARM_I2C_GetVersion function.

```c
extern ARM_DRIVER_I2C Driver_I2C0;

ARM_DRIVER_I2C *drv_info;

void setup_i2c (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_I2C0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

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

### Ethernet Interface Usage Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__interface__gr.html

Demonstrates the initialization sequence for Ethernet MAC and PHY drivers, including capability checking and MAC address configuration.

```c
extern ARM_DRIVER_ETH_MAC Driver_ETH_MAC0;

extern ARM_DRIVER_ETH_PHY Driver_ETH_PHY0;

static ARM_DRIVER_ETH_MAC *mac;

static ARM_DRIVER_ETH_PHY *phy;

static ARM_ETH_MAC_ADDR own_mac_address;

static ARM_ETH_MAC_CAPABILITIES capabilities;

void ethernet_mac_notify (uint32_t event) {

switch (event) {

:

}

}

void initialize_ethernet_interface (void) {

mac = &Driver_ETH_MAC0;

phy = &Driver_ETH_PHY0;

// Initialize Media Access Controller

capabilities = mac->GetCapabilities ();

mac->Initialize (ethernet_mac_notify);

mac->PowerControl (ARM_POWER_FULL);

if (capabilities.mac_address == 0) {

// populate own_mac_address with the address to use

mac->SetMacAddress(&own_mac_address);

}

else {

mac->GetMacAddress(&own_mac_address);

}

// Initialize Physical Media Interface
```

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

### Get USB Host HCI Driver Capabilities

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbh__hci__gr.html

Example demonstrating how to retrieve driver capabilities using ARM_USBH_HCI_GetCapabilities.

```c
extern ARM_DRIVER_USBH_HCI Driver_USBH0_HCI;

ARM_DRIVER_USBH_HCI *drv_info;

void read_capabilities (void) {

ARM_USBH_HCI_CAPABILITIES drv_capabilities;

drv_info = &Driver_USBH0_HCI;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### Read SAI Driver Capabilities

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__sai__interface__gr.html

Example showing how to retrieve the capabilities of the SAI driver implementation.

```c
extern ARM_DRIVER_SAI Driver_SAI0;

ARM_DRIVER_SAI *drv_info;

void read_capabilities (void) {

ARM_SAI_CAPABILITIES drv_capabilities;

drv_info = &Driver_SAI0;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### Kernel Information and Control

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/functionOverview.html

Functions to initialize, start, and query the RTOS kernel, as well as get system tick information.

```APIDOC
## osKernelInitialize

### Description
Initialize the RTOS kernel.

## osKernelStart

### Description
Start the RTOS kernel.

## osKernelRunning

### Description
Query if the RTOS kernel is running.

## osKernelSysTick

### Description
Get RTOS kernel system timer counter.

## osKernelSysTickFrequency

### Description
RTOS kernel system timer frequency in Hz.

## osKernelSysTickMicroSec

### Description
Convert microseconds value to RTOS kernel system timer value.
```

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

### main

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/NN/html/arm__nnexamples__gru_8cpp.html

The main function initializes test data and calls the gru_example function to demonstrate the GRU example.

```APIDOC
## main

### Description
The main function initializes test data and calls the gru_example function to demonstrate the GRU example.

### Function Signature
int main()

### Referenced Macros
- DIM_HISTORY
- DIM_INPUT

### Referenced Functions
- gru_example

### Referenced Variables
- hidden_state_bias
- hidden_state_weights
- reset_gate_bias
- reset_gate_weights
- scratch_buffer
- test_history
- test_input1
- test_input2
- update_gate_bias
- update_gate_weights
```

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

### Get USB Host HCI Driver Version

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__usbh__hci__gr.html

Example demonstrating how to retrieve and verify the driver version using ARM_USBH_HCI_GetVersion.

```c
extern ARM_DRIVER_USBH Driver_USBH0_HCI;

ARM_DRIVER_USBH *drv_info;

void setup_usbh (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_USBH0_HCI;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

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

### Get SAI Driver Version

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__sai__interface__gr.html

Example showing how to retrieve and verify the SAI driver version using the GetVersion function.

```c
extern ARM_DRIVER_SAI Driver_SAI0;

ARM_DRIVER_SAI *drv_info;

void setup_sai (void) {

ARM_DRIVER_VERSION version;

drv_info = &Driver_SAI0;

version = drv_info->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```

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

### GIC_Enable

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Core_A/html/group__GIC__functions.html

Initializes the distributor and the CPU interface.

```APIDOC
## GIC_Enable

### Description
Initializes the distributor and the CPU interface.

### Function Signature
void GIC_Enable(void)

### Parameters
None

### Return Value
None

### See Also
- GIC_DistInit
- GIC_CPUInterfaceInit
```

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

### CMSIS Cortex-A9 Example: Timer, Interrupt, and Delay

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Core_A/html/using_CMSIS.html

Complete example for using CMSIS on a Cortex-A9 device. Includes SysTick handler, PTIM initialization with IRQ setup, a delay function using WFE, and a main loop toggling an LED.

```C
#include <ARMCA9.h> // File name depends on device used

static const uint32_t TICK_RATE_HZ = 1000U;

uint32_t volatile msTicks; // Counter for millisecond Interval

static void SysTick_Handler( void )
{
  msTicks++; // Increment Counter
}

// We use the Private Tiemer (PTIM) of the Cortex-A9 FVP Model here.
// In general the available Timers are highly vendor specific for Cortex-A processors.
void private_timer_init(void) {
  PTIM_SetLoadValue ((SystemCoreClock/TICK_RATE_HZ) - 1U);
  PTIM_SetControl (PTIM_GetControl() | 7U);

  /* Install SysTick_Handler as the interrupt function for PTIM */
  IRQ_SetHandler((IRQn_ID_t)PrivTimer_IRQn, SysTick_Handler);

  /* Determine number of implemented priority bits */
  IRQ_SetPriority ((IRQn_ID_t)PrivTimer_IRQn, IRQ_PRIORITY_Msk);

  /* Set lowest priority -1 */
  IRQ_SetPriority ((IRQn_ID_t)PrivTimer_IRQn, GIC_GetPriority((IRQn_ID_t)PrivTimer_IRQn)-1);

  /* Enable IRQ */
  IRQ_Enable ((IRQn_ID_t)PrivTimer_IRQn);
}

/* Delay execution for given amount of ticks */
void Delay(uint32_t ticks) {
  uint32_t tgtTicks = msTicks + ticks; // target tick count to delay execution to
  while (msTicks == tgtTicks) {
    __WFE (); // Power-Down until next Event/Interrupt
  }
}

/* main function */
int main(void)
{
  /* Initialize device HAL here */
  private_timer_init();

  static uint8_t ledState = 0;

  /* Infinite loop */
  while (1)
  {
    /* Add application code here */
    ledState = !ledState;
    Delay(500);
  }
}
```

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

### Get MCI driver capabilities with ARM_MCI_GetCapabilities

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__mci__interface__gr.html

Example for ARM_MCI_GetCapabilities. It retrieves the driver capabilities structure and allows interrogation of supported features.

```c
extern ARM_DRIVER_MCI Driver_MCI0;

ARM_DRIVER_MCI *drv_info;

void read_capabilities (void) {

  ARM_MCI_CAPABILITIES drv_capabilities;

  drv_info = &Driver_MCI0;

  drv_capabilities = drv_info->GetCapabilities ();

  // interrogate capabilities

}
```

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

### osThreadCreate Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__ThreadMgmt.html

Demonstrates how to define and create a thread using osThreadDef and osThreadCreate, including basic error handling and termination.

```c
#include "cmsis_os.h"

void Thread_1 (void const *arg); // function prototype for Thread_1

osThreadDef (Thread_1, osPriorityNormal, 1, 0); // define Thread_1

void ThreadCreate_example (void) {

osThreadId id;

id = osThreadCreate (osThread (Thread_1), NULL); // create the thread

if (id == NULL) { // handle thread creation

// Failed to create a thread

}

:

osThreadTerminate (id); // stop the thread

}
```

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

### CMSIS-RTOS Thread and Kernel Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/usingOS.html

This example demonstrates defining thread functions, creating threads using osThreadCreate, and initializing/starting the RTOS kernel within the main function.

```c
#include "cmsis_os.h" // CMSIS-RTOS header file

void job1 (void const *argument) { // thread function 'job1'

while (1) {

: // execute some code

osDelay (10); // delay execution for 10 milliseconds

}

}

osThreadDef(job1, osPriorityAboveNormal, 1, 0); // define job1 as thread function

void job2 (void const *argument) { // thread function 'job2'

osThreadCreate(osThread(job1),NULL); // create job1 thread

while (1) {

: // execute some code

}

}

osThreadDef(job2, osPriorityNormal, 1, 0); // define job2 as thread function

void job3 (void const *argument) { // thread function 'job3'

while (1) {

: // execute some code

osDelay (20); // delay execution for 20 milliseconds

}

}

osThreadDef(job3, osPriorityNormal, 1, 0); // define job3 as thread function

int main (void) { // program execution starts here

osKernelInitialize (); // initialize RTOS kernel

: // setup and initialize peripherals

osThreadCreate (osThread(job2));

osThreadCreate (osThread(job3));

osKernelStart (); // start kernel with job2 execution

}
```

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

### Get SysTick count for sub-millisecond delay

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/CMSIS_RTOS_Tutorial.pdf

Retrieves the current kernel system tick value to be used as a start reference for a microsecond delay.

```C
int32_t tick,delayPeriod;
tick = osKernelSysTick(); // get start value of the Kernel system tick
```

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

### Add components section with BSP bundle

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Pack/html/createPackBoard.html

Define a bundle 'MyDevBoardSupport' with three components: Board Setup, LED, and GPIO. Each component includes documentation, header, and source files.

```XML
<bundle Cbundle="MyDevBoardSupport" Cclass="Board Support" Cversion="1.0.1">

<description>MyDevBoard custom board support package</description>

<doc>Docs/BSP/MyBSP.htm</doc>

<component Cgroup="Board Setup" condition="ARM Cortex M3 Series">

<description>Custom board setup code</description>

<files>

<file category="doc" name="Docs/BSP/Setup.htm"/>

<file category="header" name="MySWComp/Include/setup.h"/>

<file category="source" name="MySWComp/Source/setup.c"/>

</files>

</component>

<component Cgroup="I/O" Csub="LED" condition="MyDevBoard Board Setup">

<description>LED code for custom board</description>

<files>

<file category="doc" name="Docs/BSP/LED.htm"/>

<file category="header" name="MySWComp/Include/led.h"/>

<file category="header" name="MySWComp/Include/config_led.h" attr="config" version="1.0.0"/>

<file category="source" name="MySWComp/Source/led.c"/>

</files>

</component>

<component Cgroup="I/O" Csub="GPIO" condition="MyDevBoard Board Setup">

<description>GPIO code for custom board</description>

<files>

<file category="doc" name="Docs/BSP/GPIO.htm"/>

<file category="header" name="MySWComp/Include/gpio.h"/>

<file category="header" name="MySWComp/Include/config_gpio.h" attr="config" version="1.0.0"/>

<file category="source" name="MySWComp/Source/gpio.c"/>

</files>

</component>

</bundle>
```

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

### Kernel Lock and Restore Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Demonstrates how to use osKernelLock, osKernelUnlock, and osKernelRestoreLock to manage critical sections.

```c
int32_t sl = osKernelLock();

// ... critical code

{

int32_t su = osKernelUnlock();

// ... uncritical code

osKernelRestoreLock(su);

}

// ... critical code

osKernelRestoreLock(sl);
```

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

### Initialize the RTOS Kernel

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Initializes the RTOS kernel to allow peripheral setup and creation of RTOS objects. Thread switching does not start until osKernelStart is called.

```c
#include "cmsis_os.h"

int main (void) {

if (!osKernelRunning ()) { // if kernel is not running, initialize the kernel

if (osKernelInitialize () != osOK) { // check osStatus for other possible valid values

// exit with an error message

}

}

:

}
```

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

### Static Instance Structure Initialization

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/DSP/html/group__FIR__Interpolate.html

Example of how to statically initialize the instance structures for different data types.

```c
arm_fir_interpolate_instance_f32 S = {L, phaseLength, pCoeffs, pState};
arm_fir_interpolate_instance_q31 S = {L, phaseLength, pCoeffs, pState};
arm_fir_interpolate_instance_q15 S = {L, phaseLength, pCoeffs, pState};
```

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

### Retrieve Driver Capabilities with ARM_Storage_GetCapabilities

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__storage__interface__gr.html

Example showing how to retrieve the capabilities structure of the storage driver.

```c
extern ARM_DRIVER_STORAGE *drv_info;

void read_capabilities (void) {

ARM_STORAGE_CAPABILITIES drv_capabilities;

drv_capabilities = drv_info->GetCapabilities ();

// interrogate capabilities

}
```

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

### memory element configuration

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Pack/html/cpdsc_pg.html

Example of the memory element used to define the memory layout, including access permissions, start addresses, and sizes for the linker script generation.

```xml
<project name="STM32F429\_Flash" documentation="./Abstract.txt">

<target Dendian="Little-endian" Dfpu="SP\_FPU" Dname="STM32F429ZITx" Dvendor="STMicroelectronics:13">

...

<memory access="rx" default="1" name="IROM1" size="0x200000" start="0x8000000" startup="1"/>

<memory access="rw" default="1" init="1" name="IRAM1" size="0x30000" start="0x20000000"/>

<memory access="rw" default="0" init="1" name="IRAM2" size="0x10000" start="0x10000000"/>

...

</target>

</project>
```

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

### ARM_ETH_MAC_GetVersion Example

Source: https://github.com/stmicroelectronics/stm32cubef1/blob/master/Drivers/CMSIS/docs/Driver/html/group__eth__mac__interface__gr.html

Demonstrates how to retrieve and check the driver version using the ARM_ETH_MAC_GetVersion function.

```c
extern ARM_DRIVER_ETH_MAC Driver_ETH_MAC0;

ARM_DRIVER_ETH_MAC *mac;

void setup_ethernet (void) {

ARM_DRIVER_VERSION version;

mac = &Driver_ETH_MAC0;

version = mac->GetVersion ();

if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher

// error handling

return;

}

}
```
Tokens:
Raw