STM32CubeF4 MCU Firmware Package

https://github.com/stmicroelectronics/stm32cubef4
Admin
STM32CubeF4 is a comprehensive embedded software platform for STM32F4 series microcontrollers,...
Tokens:2,645,181
Snippets:17,842
Trust Score:9.8
Update:1 month ago
Show doc for...
Tokens:
Raw
### Ethernet Interface Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__eth__interface__gr.html

Shows the typical setup sequence for the Ethernet MAC and PHY drivers. It declares external driver instances, initializes the MAC, configures power, and handles MAC address setup based on capabilities. The PHY initialization is also started but not shown in full.

```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
}
```

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

### MPU region setup and enable/disable example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Core/html/group__mpu__functions.html

Shows how to configure an MPU region using ARM_MPU_SetRegionEx and ARM_MPU_RASR, then enable and disable the MPU. The example sets Region 0 to cover 1MB starting at 0x08000000 with full access permissions.

```c
int main()

{

// Set Region 0

ARM_MPU_SetRegionEx(0UL, 0x08000000UL, ARM_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();

}
```

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

### Convolution Example Setup and Data Declaration

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/DSP/html/arm_convolution_example_f32_8c-example.html

This snippet includes the necessary headers, defines constants for the convolution process, and declares the input and output buffers for the floating-point convolution example.

```c
/* ----------------------------------------------------------------------
* Copyright (C) 2010-2012 ARM Limited. All rights reserved.
*
* $Date: 17. January 2013
* $Revision: V1.4.0
*
* Project: CMSIS DSP Library
* Title: arm_convolution_example_f32.c
*
* Description: Example code demonstrating Convolution of two input signals using fft.
*
* Target Processor: Cortex-M4/Cortex-M3
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* -------------------------------------------------------------------- */

#include "arm_math.h"
#include "math_helper.h"
#if defined(SEMIHOSTING)
#include <stdio.h>
#endif

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

/* ----------------------------------------------------------------------
* Declare I/O buffers
* ------------------------------------------------------------------- */
float32_t Ak[MAX_BLOCKSIZE]; /* Input A */
float32_t Bk[MAX_BLOCKSIZE]; /* Input B */
float32_t AxB[MAX_BLOCKSIZE * 2]; /* Output */

/* ----------------------------------------------------------------------
* Test input data for Floating point Convolution example for 32-blockSize
* Generated by the MATLAB randn() function
* ------------------------------------------------------------------- */
float32_t testInputA_f32[64] =
{

```

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

### Example: Get driver version and check API version

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__eth__phy__interface__gr.html

Shows how to get the driver version and check the API version. The example requires API version 1.10 or higher; if the version is lower, an error handling block is executed.

```c
extern ARM_DRIVER_ETH_PHY Driver_ETH_PHY0;

ARM_DRIVER_ETH_PHY *drv_info;

void setup_ethernet_phy (void) {

  ARM_DRIVER_VERSION version;

  drv_info = &Driver_ETH_PHY0;
  version = drv_info->GetVersion ();

  if (version.api < 0x10A) { // requires at minimum API version 1.10 or higher
    // error handling
    return;
  }
}
```

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

### osKernelInitialize code example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows how to initialize the CMSIS-RTOS kernel and start the application main thread. Includes system initialization and thread creation.

```c
#include "RTE_Components.h"

#include CMSIS_device_header

#include "cmsis_os2.h"

/*----------------------------------------------------------------------------
 * Application main thread
 *---------------------------------------------------------------------------*/
void app_main (void *argument) {

  // ...
  for (;;) {}
}

int main (void) {

  // System Initialization
  SystemCoreClockUpdate();
  // ...

  osKernelInitialize();                    // Initialize CMSIS-RTOS

  osThreadNew(app_main, NULL, NULL);       // Create application main thread

  osKernelStart();                         // Start thread execution

  for (;;) {}
}
```

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

### Initialize and start the RTOS scheduler in main

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

Use osKernelInitialize to halt the scheduler for setup, perform custom initialization, and osKernelStart to begin thread execution.

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

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

### Get driver capabilities example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__sai__interface__gr.html

Example for ARM_SAI_GetCapabilities. It retrieves the driver capabilities and stores them in a variable for interrogation.

```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
}
```

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

### Initialize and start RTX kernel with priority grouping

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/cre_rtx_proj.html

This example shows the sequence to initialize RTX, set priority grouping, create a thread, and start the kernel. It must be used on Cortex-M processors, and the priority grouping should be set before osKernelStart(). The code uses osKernelInitialize, NVIC_SetPriorityGrouping, osThreadNew, and osKernelStart.

```c
osKernelInitialize(); // initialize RTX
NVIC_SetPriorityGrouping (3); // setup priority grouping
tread_id = osThreadNew(tread_func, NULL, NULL); // create some threads
osKernelStart (); // start RTX kernel
```

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

### ARM_USBD_GetCapabilities example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__usbd__interface__gr.html

Shows how to get driver capabilities using ARM_USBD_GetCapabilities. The capabilities structure can be interrogated to determine supported features.

```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
}
```

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

### CMSIS-RTOS thread and kernel initialization example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/usingOS.html

This example shows how to define and create threads using osThreadDef and osThreadCreate, and how to initialize and start the RTOS kernel with osKernelInitialize and osKernelStart. It includes three thread functions (job1, job2, job3) with delays, and the main function that sets up the kernel and starts the threads.

```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
}
```

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

### Start RTOS Kernel with osKernelStart

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Starts the RTOS kernel and begins thread switching. Cannot be called from interrupt service routines. The example initializes the kernel, checks if it is not running, and then starts it, checking the returned status code.

```c
#include "cmsis_os.h"

int main (void) {

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

    // exit with an error message

  }

  if (!osKernelRunning ()) {           // is the kernel running ?

    if (osKernelStart () != osOK) {    // start the kernel

      // further error handling

    }

  }
:
}

```

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

### CMSIS-RTOS2 kernel initialization and start example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows the typical startup sequence for a CMSIS-RTOS2 application: initialize the kernel with osKernelInitialize(), create the main thread with osThreadNew(), and start the scheduler with osKernelStart(). The main function then enters an idle loop. The kernel initialization for RTX5 is documented in the System Startup section.

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

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

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

### Main example: configure and enable MPU

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Core/html/group__mpu8__functions.html

Shows how to use ARM_MPU_SetMemAttr, ARM_MPU_SetRegion, ARM_MPU_Enable, and ARM_MPU_Disable to set a memory region, enable the MPU, and then disable it after executing protected code.

```c
int main()

{

// Set Region 0 using Attr 0

ARM_MPU_SetMemAttr(0UL, ARM_MPU_ATTR( /* Normal memory */

ARM_MPU_ATTR_MEMORY_(0UL, 1UL, 1UL, 1UL), /* Outer Write-Back transient with read and write allocate */

ARM_MPU_ATTR_MEMORY_(0UL, 0UL, 1UL, 1UL) /* Inner Write-Through transient with read and write allocate */

));

ARM_MPU_SetRegion(0UL,

ARM_MPU_RBAR(0x08000000UL, ARM_MPU_SH_NON, 0UL, 1UL, 1UL), /* Non-shareable, read/write, non-privileged, execute-never */

ARM_MPU_RLAR(0x080FFFFFUL, 0UL) /* 1MB memory block using Attr 0 */

);

ARM_MPU_Enable(0);

// Execute application code that is access protected by the MPU

ARM_MPU_Disable();

}
```

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

### ARM_WIFI_Activate configuration example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__wifi__management__gr.html

Example of setting up a WiFi configuration for connecting to a network with SSID 'GuestAccess', password 'guest', WPA2 security, and automatic channel selection.

```c
ARM_WIFI_CONFIG_t wifi_config;

wifi_config.ssid = "GuestAccess";
wifi_config.pass = "guest";
wifi_config.security = ARM_WIFI_SECURITY_WPA2;
wifi_config.ch = 0U;
```

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

### osKernelSysTick timeout check example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Use this snippet to poll a device or peripheral busy status with a timeout based on the kernel system tick. The example gets the start tick, initializes the device, then polls until the device is not busy or 100 microseconds have elapsed. Note that osKernelSysTick cannot be called from interrupt service routines.

```c
#include "cmsis_os.h"

void SetupDevice (void) {

  uint32_t tick;

  tick = osKernelSysTick();  // get start value of the Kernel system tick

  Device.Setup ();           // initialize a device or peripheral

  do {                       // poll device busy status for 100 microseconds

    if (!Device.Busy) break; // check if device is correctly initialized

  } while ((osKernelSysTick() - tick) < osKernelSysTickMicroSec(100));

  if (Device.Busy) {

    ; // in case device still busy, signal error

  }

  // start interacting with device

}
```

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

### FIR LPF example: global buffers, coefficients, and main() setup

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/DSP/html/arm_fir_example_f32_8c-example.html

Global declarations and the start of the FIR LPF example main() function. The state buffer and coefficient array sizes depend on whether ARM_MATH_MVEF is defined without ARM_MATH_AUTOVECTORIZE. The coefficient buffer is generated with MATLAB fir1(28, 6/24).

```c
static float32_t testOutput[TEST_LENGTH_SAMPLES];
```

```c
/* -------------------------------------------------------------------
 * Declare State buffer of size (numTaps + blockSize - 1)
 * ------------------------------------------------------------------- */
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
static float32_t firStateF32[2 * BLOCK_SIZE + NUM_TAPS - 1];
#else
static float32_t firStateF32[BLOCK_SIZE + NUM_TAPS - 1];
#endif
```

```c
/* ----------------------------------------------------------------------
** FIR Coefficients buffer generated using fir1() MATLAB function.
** fir1(28, 6/24)
** ------------------------------------------------------------------- */
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
const float32_t firCoeffs32[NUM_TAPS_ARRAY_SIZE] = {
-0.0018225230f, -0.0015879294f, +0.0000000000f, +0.0036977508f, +0.0080754303f, +0.0085302217f, -0.0000000000f, -0.0173976984f,
-0.0341458607f, -0.0333591565f, +0.0000000000f, +0.0676308395f, +0.1522061835f, +0.2229246956f, +0.2504960933f, +0.2229246956f,
+0.1522061835f, +0.0676308395f, +0.0000000000f, -0.0333591565f, -0.0341458607f, -0.0173976984f, -0.0000000000f, +0.0085302217f,
+0.0080754303f, +0.0036977508f, +0.0000000000f, -0.0015879294f, -0.0018225230f, 0.0f,0.0f,0.0f
};
#else
const float32_t firCoeffs32[NUM_TAPS_ARRAY_SIZE] = {
-0.0018225230f, -0.0015879294f, +0.0000000000f, +0.0036977508f, +0.0080754303f, +0.0085302217f, -0.0000000000f, -0.0173976984f,
-0.0341458607f, -0.0333591565f, +0.0000000000f, +0.0676308395f, +0.1522061835f, +0.2229246956f, +0.2504960933f, +0.2229246956f,
+0.1522061835f, +0.0676308395f, +0.0000000000f, -0.0333591565f, -0.0341458607f, -0.0173976984f, -0.0000000000f, +0.0085302217f,
+0.0080754303f, +0.0036977508f, +0.0000000000f, -0.0015879294f, -0.0018225230f
};
#endif
```

```c
/* ------------------------------------------------------------------
 * Global variables for FIR LPF Example
 * ------------------------------------------------------------------- */
uint32_t blockSize = BLOCK_SIZE;
uint32_t numBlocks = TEST_LENGTH_SAMPLES/BLOCK_SIZE;
float32_t snr;
```

```c
/* ----------------------------------------------------------------------
 * FIR LPF Example
 * ------------------------------------------------------------------- */
int32_t main(void)
{
uint32_t i;
arm_fir_instance_f32 S;
arm_status status;
float32_t *inputF32, *outputF32;

/* Initialize input and output buffer pointers */
inputF32 = &testInput_f32_1kHz_15kHz[0];
outputF32 = &testOutput[0];

/* Call FIR init function to initialize the instance structure. */
```

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

### Initialize RTOS Kernel with osKernelInitialize

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Initializes the RTOS kernel to allow peripheral setup and creation of other RTOS objects. The kernel does not start thread switching until osKernelStart is called. The example checks if the kernel is not running, then initializes it and checks the returned status code.

```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

    }

  }
:
}

```

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

### ARM_MPU_Load Example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Core/html/group__mpu8__functions.html

Example demonstrating how to define an MPU configuration table and load it using the ARM_MPU_Load function.

```c
const ARM_MPU_Region_t mpuTable[1][4] = {

{

// BASE SH RO NP XN LIMIT ATTR

{ .RBAR = ARM_MPU_RBAR(0x08000000UL, ARM_MPU_SH_NON, 0UL, 1UL, 0UL), .RLAR = ARM_MPU_RLAR(0x080FFFFFUL, 0UL) },

{ .RBAR = ARM_MPU_RBAR(0x20000000UL, ARM_MPU_SH_NON, 0UL, 1UL, 1UL), .RLAR = ARM_MPU_RLAR(0x20007FFFUL, 0UL) },

{ .RBAR = ARM_MPU_RBAR(0x40020000UL, ARM_MPU_SH_NON, 0UL, 1UL, 1UL), .RLAR = ARM_MPU_RLAR(0x40021FFFUL, 1UL) },

{ .RBAR = ARM_MPU_RBAR(0x40022000UL, ARM_MPU_SH_NON, 0UL, 1UL, 1UL), .RLAR = ARM_MPU_RLAR(0x40022FFFUL, 1UL) }

}

};

void UpdateMpu(uint32_t idx)

{

ARM_MPU_Load(0, mpuTable[idx], 4);

}
```

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

### Check if RTOS Kernel is Running with osKernelRunning

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__KernelCtrl.html

Identifies if the RTOS kernel is started. Returns 0 if not started, 1 if started. Can be called from interrupt service routines. The example shows checking the kernel running state at the start of main.

```c
#include "cmsis_os.h"

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

  if (osKernelRunning ()) {
:
    // main is already a thread function

  }
}

```

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

### Get driver version example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__sai__interface__gr.html

Example for ARM_SAI_GetVersion. It retrieves the driver version and checks if the API version is at least 1.10, performing error handling if not.

```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;
  }
}
```

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

### osKernelStart: Initialize and start the RTOS kernel

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows the typical main function flow: initialize the kernel if inactive, then start it if ready. The while(1) loop is only reached in case of error.

```c
int main (void) {

// System Initialization
SystemCoreClockUpdate();
// ...

if(osKernelGetState() == osKernelInactive) { // Is the kernel initialized?
  osKernelInitialize(); // Initialize CMSIS-RTOS kernel
}

;

}
```

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

### SystemInit

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/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

### Notes
This function is typically called at startup to configure the system clock and other essential hardware.
```

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

### Set PHY Mode Example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__eth__phy__interface__gr.html

Example of setting the PHY mode using the SetMode function. It shows how to get capabilities, set the interface, and handle errors.

```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
```

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

### SPI driver initialization and callback example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__spi__interface__gr.html

Shows the SPI driver usage: includes the SPI header and RTOS header, declares a thread and callback, initializes the driver, powers it up, and begins configuration for master 8-bit mode at 10000 kBits/sec. The callback handles transfer complete, data lost, and mode fault events. The DEBUG section checks API version and capabilities before proceeding.

```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 socket peer name example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__wifi__socket__gr.html

Example of using ARM_WIFI_SocketGetPeerName to retrieve the IP address and port of a connected peer. The example declares buffers for the IP and port, then calls the function with the socket handle and pointers to the buffers.

```c
static uint8_t peer_ip[4]; // Socket address and port

static uint16_t peer_port;

static void get_socket_peer_info (void) {

uint32_t ip_len;

ip_len = sizeof(peer_ip);

wifi->SocketGetPeerName (sock, (uint8_t *)peer_ip, &ip_len, &peer_port);

}
```

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

### Initialize WiFi and Retrieve Module Info

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__wifi__control__gr.html

Shows how to initialize and power on a WiFi module, then retrieve its information using ARM_WIFI_GetModuleInfo. The module must be initialized and powered before retrieval. The example uses the global Driver_WiFi0 and a static pointer.

```c
extern ARM_DRIVER_WIFI Driver_WiFi0;

static ARM_DRIVER_WIFI *wifi;

void initialize_wifi (void) {

char info[32];

wifi = &Driver_WiFi0;

// Initialize and Power-on WiFi Module

wifi->Initialize (NULL);

wifi->PowerControl (ARM_POWER_FULL);

// Retrieve module information

wifi->GetModuleInfo(&info, sizeof(info));

}
```

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

### MCI Driver Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__mci__interface__gr.html

Shows how to initialize the MCI driver and register an event callback. The function checks the return status against ARM_DRIVER_OK to verify successful initialization.

```c
#include "Driver_MCI.h"

/* Usage example: ARM_MCI_Initialize ----------------------------------------*/

// ARM_MCI_SignalEvent callback function prototype

void MCI_SignalEvent_Callback (uint32_t event);

void init_driver (ARM_DRIVER_MCI *drv) {

int32_t status;

status = drv->Initialize (&MCI_SignalEvent_Callback);

if (status != ARM_DRIVER_OK) {

// Initialization and event callback registration failed

}

}
```

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

### Get USB Host HCI driver version

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__usbh__hci__gr.html

Example for ARM_USBH_HCI_GetVersion. Declares an external driver instance, gets the version, and checks that the API version is at least 1.10.

```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;
  }
}
```

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

### CAN Interface Usage Example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__can__interface__gr.html

Complete example showing how to initialize and configure a CAN controller, set up receive and transmit objects, and handle events. Includes error handling and event callbacks.

```c
#include <stdio.h>

#include <string.h>

#include "cmsis_os.h"

#include "Driver_CAN.h"

// CAN Driver Controller selector

#define CAN_CONTROLLER 1 // CAN Controller number

#define _CAN_Driver_(n) Driver_CAN##n

#define CAN_Driver_(n) _CAN_Driver_(n)

extern ARM_DRIVER_CAN CAN_Driver_(CAN_CONTROLLER);

#define ptrCAN (&CAN_Driver_(CAN_CONTROLLER))

uint32_t rx_obj_idx = 0xFFFFFFFFU;

uint8_t rx_data[8];

ARM_CAN_MSG_INFO rx_msg_info;

uint32_t tx_obj_idx = 0xFFFFFFFFU;

uint8_t tx_data[8];

ARM_CAN_MSG_INFO tx_msg_info;

static void Error_Handler (void) { while (1); }

void CAN_SignalUnitEvent (uint32_t event) {}

void CAN_SignalObjectEvent (uint32_t obj_idx, uint32_t event) {

if (obj_idx == rx_obj_idx) { // If receive object event

if (event == ARM_CAN_EVENT_RECEIVE) { // If message was received successfully

if (ptrCAN->MessageRead(rx_obj_idx, &rx_msg_info, rx_data, 8U) > 0U) {

// Read received message

// process received message ...

}

}

}

if (obj_idx == tx_obj_idx) { // If transmit object event

if (event == ARM_CAN_EVENT_SEND_COMPLETE) { // If message was sent successfully

// acknowledge sent message ...

}

}

}

int main (void) {

ARM_CAN_CAPABILITIES can_cap;

ARM_CAN_OBJ_CAPABILITIES can_obj_cap;

int32_t status;

uint32_t i, num_objects;

can_cap = ptrCAN->GetCapabilities (); // Get CAN driver capabilities

num_objects = can_cap.num_objects; // Number of receive/transmit objects

status = ptrCAN->Initialize (CAN_SignalUnitEvent, CAN_SignalObjectEvent); // Initialize CAN driver

if (status != ARM_DRIVER_OK ) { Error_Handler(); }

status = ptrCAN->PowerControl (ARM_POWER_FULL); // Power-up CAN controller

if (status != ARM_DRIVER_OK ) { Error_Handler(); }

status = ptrCAN->SetMode (ARM_CAN_MODE_INITIALIZATION); // Activate initialization mode

if (status != ARM_DRIVER_OK ) { Error_Handler(); }

status = ptrCAN->SetBitrate (ARM_CAN_BITRATE_NOMINAL, // Set nominal bitrate

100000U, // Set bitrate to 100 kbit/s

ARM_CAN_BIT_PROP_SEG(5U) | // Set propagation segment to 5 time quanta

ARM_CAN_BIT_PHASE_SEG1(1U) | // Set phase segment 1 to 1 time quantum (sample point at 87.5% of bit time)

ARM_CAN_BIT_PHASE_SEG2(1U) | // Set phase segment 2 to 1 time quantum (total bit is 8 time quanta long)

ARM_CAN_BIT_SJW(1U)); // Resynchronization jump width is same as phase segment 2

if (status != ARM_DRIVER_OK ) { Error_Handler(); }

for (i = 0U; i < num_objects; i++) { // Find first available object for receive and transmit

can_obj_cap = ptrCAN->ObjectGetCapabilities (i); // Get object capabilities

if ((rx_obj_idx == 0xFFFFFFFFU) && (can_obj_cap.rx == 1U)) { rx_obj_idx = i; }
```

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

### osTimerStart example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

Shows how to start a periodic timer. The callback function is called every second after the timer starts. The timer must have been created with osTimerCreate. The function cannot be called from interrupt service routines.

```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
    }
  }

  :
}
```

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

### FFT Bin Example main function

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/DSP/html/arm_fft_bin_example_f32_8c-example.html

This snippet shows the main function of the FFT bin example. It initializes the FFT, processes the input, computes magnitudes, finds the max bin, and checks against a reference. It uses semihosting for output if defined, otherwise it loops forever.

```c
uint32_t refIndex = 213, testIndex = 0;

/* ----------------------------------------------------------------------
 * Max magnitude FFT Bin test
 * ------------------------------------------------------------------- */
int32_t main(void)
{
  arm_status status;
  float32_t maxValue;

  status = ARM_MATH_SUCCESS;

  status=arm_cfft_init_f32(&varInstCfftF32,fftSize);

  /* Process the data through the CFFT/CIFFT module */
  arm_cfft_f32(&varInstCfftF32, testInput_f32_10khz, ifftFlag, doBitReverse);

  /* Process the data through the Complex Magnitude Module for
  calculating the magnitude at each bin */
  arm_cmplx_mag_f32(testInput_f32_10khz, testOutput, fftSize);

  /* Calculates maxValue and returns corresponding BIN value */
  arm_max_f32(testOutput, fftSize, &maxValue, &testIndex);

  status = (testIndex !=  refIndex) ? ARM_MATH_TEST_FAILURE : ARM_MATH_SUCCESS;

  if (status != ARM_MATH_SUCCESS)
  {
#if defined (SEMIHOSTING)
    printf("FAILURE\n");
#else
    while (1); /* main function does not return */
#endif
  }
  else
  {
#if defined (SEMIHOSTING)
    printf("SUCCESS\n");
#else
    while (1); /* main function does not return */
#endif
  }
}
```

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

### Ethernet MAC configuration and control example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__eth__mac__interface__gr.html

Configures the MAC for 100 Mbps full-duplex, enables TX and RX, and flushes the buffers. The example shows the sequence: configure, enable TX, enable RX, then flush.

```c
mac->Control(ARM_ETH_MAC_CONFIGURE, ARM_ETH_MAC_SPEED_100M | ARM_ETH_MAC_DUPLEX_FULL | ARM_ETH_MAC_ADDRESS_BROADCAST);

mac->Control(ARM_ETH_MAC_CONTROL_TX, 1);

mac->Control(ARM_ETH_MAC_CONTROL_RX, 1);

... // stop transfer

mac->Control(ARM_ETH_MAC_FLUSH, ARM_ETH_MAC_FLUSH_TX | ARM_ETH_MAC_FLUSH_RX);
```

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

### Get USART driver capabilities example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__usart__interface__gr.html

Shows how to retrieve driver capabilities using ARM_USART_GetCapabilities. It declares an external driver instance, gets a pointer to it, and calls GetCapabilities to obtain the capabilities structure.

```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
}
```

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

### Get driver capabilities with ARM_SPI_GetCapabilities

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__spi__interface__gr.html

Example for ARM_SPI_GetCapabilities. It retrieves the driver capabilities into a local variable for interrogation.

```c
extern ARM_DRIVER_SPI Driver_SPI0;
ARM_DRIVER_SPI *drv_info;

void read_capabilities (void) {
  ARM_SPI_CAPABILITIES drv_capabilities;

  drv_info = &Driver_SPI0;
  drv_capabilities = drv_info->GetCapabilities ();
  // interrogate capabilities
}
```

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

### Get USART driver version example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__usart__interface__gr.html

Shows how to obtain the driver version using ARM_USART_GetVersion. It declares an external driver instance, gets a pointer to it, and checks the API version against a minimum required version (0x10A).

```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;
  }
}
```

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

### osKernelStart: Start thread execution after initialization

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Shows the second part of the main function: after initializing the kernel, start thread execution if the kernel is ready. The while(1) loop is only reached in case of error.

```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

}
```

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

### CMSIS_DAP_v2.inf file for Windows 7 driver installation

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/DAP/html/group__DAP__ConfigUSB__gr.html

The sample .inf file provided for automatic driver installation of a CMSIS-DAP v2 device on Windows 7. It includes the necessary sections for version, manufacturer, class installation, and device interfaces. The file references the WinUSB GUID {CDB3B5AD-293B-4663-AA36-1AAE46463776} for the device interface.

```inf
[Version]
Signature = "$Windows NT$"
Class     = USBDevice
ClassGUID = {88BAE032-5A81-49f0-BC3D-A4FF138216D6}
Provider  = %ManufacturerName%
DriverVer = 04/13/2016, 1.0.0.0
CatalogFile.nt      = CMSIS_DAP_v2_x86.cat
CatalogFile.ntx86   = CMSIS_DAP_v2_x86.cat
CatalogFile.ntamd64 = CMSIS_DAP_v2_amd64.cat

; ========== Manufacturer/Models sections ===========

[Manufacturer]
%ManufacturerName% = Devices, NTx86, NTamd64

[Devices.NTx86]
%DeviceName% = USB_Install, USB\VID_c251&PID_f000

[Devices.NTamd64]
%DeviceName% = USB_Install, USB\VID_c251&PID_f000

; ========== Class definition ===========

[ClassInstall32]
AddReg = ClassInstall_AddReg

[ClassInstall_AddReg]
HKR,,,,%ClassName%
HKR,,NoInstallClass,,1
HKR,,IconPath,0x10000,"%%SystemRoot%%\System32\setupapi.dll,-20"
HKR,,LowerLogoVersion,,5.2

; =================== Installation ===================

[USB_Install]
Include = winusb.inf
Needs   = WINUSB.NT

[USB_Install.Services]
Include = winusb.inf
Needs   = WINUSB.NT.Services

[USB_Install.HW]
AddReg  = Dev_AddReg

[Dev_AddReg]
HKR,,DeviceInterfaceGUIDs,0x10000,"{CDB3B5AD-293B-4663-AA36-1AAE46463776}"

; =================== Strings ===================

[Strings]
ClassName        = "Universal Serial Bus devices"
ManufacturerName = "KEIL - Tools By ARM"
DeviceName       = "CMSIS-DAP v2" 

```

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

### osKernelStart

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Starts the RTOS kernel and begins thread switching. It does not return on success and requires at least one initial thread to be created before calling.

```APIDOC
## osKernelStart

### Description
Starts the RTOS kernel and begins thread switching. It will not return to its calling function in case of success. Before it is successfully executed, only the functions osKernelGetInfo, osKernelGetState, and object creation functions (osXxxNew) may be called.

### Method
Function

### Signature
```c
osStatus_t osKernelStart(void)
```

### Parameters
None

### Returns
- **osStatus_t** - status code that indicates the execution status of the function.
  - _osError_ if an unspecific error occurred.
  - _osErrorISR_ if called from an Interrupt Service Routine.

### Notes
- This function **cannot** be called from Interrupt Service Routines.
- At least one initial thread should be created prior to calling osKernelStart, see osThreadNew.

### Code Example
```c
int main (void) {
  // System Initialization
  SystemCoreClockUpdate();
  // ...
  if (osKernelGetState() == osKernelInactive) { // Is the kernel initialized?
    osKernelInitialize(); // Initialize CMSIS-RTOS kernel
  }
  ;
  // ... Start Threads
  if (osKernelGetState() == osKernelReady) { // If kernel is ready to run...
    osKernelStart(); // ... start thread execution
  }
  while(1); // only reached in case of error
}
```
```

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

### Timer Delete Example (CMSIS-RTOS2)

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__TimerMgmt.html

This example shows how to create a periodic timer, start it, and then delete it using osTimerDelete. It includes a callback function prototype and demonstrates checking the return status. Note that osTimerDelete cannot be called from interrupt service routines.

```c
#include "cmsis_os2.h"

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

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

void TimerDelete_example (void) {

  osTimerId_t id; // timer id

  osStatus_t status; // function return status

  // Create periodic timer

  exec = 1U;

  id = osTimerNew(Timer_Callback, osTimerPeriodic, &exec, NULL);

  osTimerStart(id, 1000U); // start timer

  ;

  status = osTimerDelete(id); // stop and delete timer

  if (status != osOK) {

    // Timer could not be deleted

  }

  ;

}
```

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

### Exercise: message queue initialization in main

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

Initializes the LED, creates the message queue, and defines the event structure in the main thread. The queue uses unsigned char elements.

```c
osMessageQId Q_LED;
osMessageQDef (Q_LED,0x16,unsigned char);
osEvent result;
int main (void) {
  LED_Init ();
  Q_LED = osMessageCreate(osMessageQ(Q_LED),NULL);
```

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

### __STATIC_INLINE macro usage example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Core_A/html/group__comp__cntrl__gr.html

Defines a static function that may be inlined by the compiler. If the compiler generates inline code for all calls, no additional function implementation is generated. The example shows a function to get the interrupt priority from the GIC distributor.

```c
__STATIC_INLINE uint32_t GIC_GetPriority(IRQn_Type IRQn)

{

return((uint32_t)GICDistributor->D_IPRIORITYR[((uint32_t)(int32_t)IRQn)]);

}
```

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

### Main function with kernel initialization and thread creation

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/RTOS2/html/rtos2_tutorial.html

Shows the main function that initializes the kernel, creates a launcher thread, and starts the RTOS. The launcher thread creates the actual application threads.

```c
void app\_main(void \*argument) {

T\_led\_ID1 = osThreadNew(led\_Thread1, NULL, &ThreadAttr\_LED1);

T\_led\_ID2 = osThreadNew(led\_Thread2, NULL, &ThreadAttr\_LED2);

osDelay(osWaitForever);

while (1)

;

}

void main(void) {

IODIR1 = 0x00FF0000; // Do any C code you want

osKernelInitialize(); // Initialize the kernel

osThreadNew(app\_main, NULL, NULL); // Create the app\_main() launcher thread

osKernelStart(); // Start the RTOS

}
```

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

### ARM_USBD_GetVersion example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__usbd__interface__gr.html

Shows how to get the driver version using ARM_USBD_GetVersion. It checks that the API version is at least 1.10 and handles errors if not.

```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;
  }
}
```

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

### Get driver capabilities example

Source: https://github.com/stmicroelectronics/stm32cubef4/blob/master/Drivers/CMSIS/Documentation/Driver/html/group__can__interface__gr.html

Shows how to retrieve the driver capabilities using ARM_CAN_GetCapabilities. It stores the capabilities in a local variable for interrogation.

```c
extern ARM_DRIVER_CAN Driver_CAN0;

ARM_DRIVER_CAN *drv_info;

void read_capabilities (void) {

  ARM_CAN_CAPABILITIES drv_capabilities;

  drv_info = &Driver_CAN0;
  drv_capabilities = drv_info->GetCapabilities ();
  // interrogate capabilities
}
```
Tokens:
Raw