Copyright 2022 STMicroelectronics
The STM32CubeWBA Firmware package comes with a rich set of examples running on STMicroelectronics boards, organized by board and provided with preconfigured projects for the main supported toolchains.
The examples are classified depending on the STM32Cube level they apply to, and are named as follows:
The examples are located under STM32Cube_FW_WBA_VX.Y.Z\Projects\, and all of them have the same structure:
To run the example, you have to do the following:
The provided examples can be tailored to run on any compatible hardware; user simply need to update the BSP drivers for his board, if it has the same hardware functions (LED, LCD display, pushbuttons...etc.). The BSP is based on a modular architecture that allows it to be ported easily to any hardware by just implementing the low level routines.
Level | Module Name | Project Name | Description | NUCLEO-WBA52CG |
Templates |
- |
TrustZoneDisabled |
- This project provides a reference template based on the STM32Cube HAL API that can be used to build any firmware application when security is not enabled (TZEN=0). | X |
TrustZoneEnabled |
- This project provides a reference template based on the STM32Cube HAL API that can be used to build any firmware application when TrustZone security is activated (Option bit TZEN=1). | X | ||
Total number of templates: 2 | 2 | |||
Templates_LL |
- |
TrustZoneDisabled |
- This project provides a reference template based on the STM32Cube LL API that can be used to build any firmware application. | X |
Total number of templates_ll: 1 | 1 | |||
Examples |
ADC |
ADC_AnalogWatchdog |
How to use an ADC peripheral with an ADC analog watchdog to monitor a channel and detect when the corresponding conversion data is outside the window thresholds. | CubeMx |
ADC_MultiChannelSingleConversion |
How to use an ADC peripheral to convert several channels. ADC conversions are performed successively in a scan sequence. | CubeMx | ||
ADC_Oversampling |
How to use an ADC peripheral with oversampling. | CubeMx | ||
ADC_SingleConversion_TriggerSW_IT |
How to use ADC to convert a single channel at each SW start, conversion performed using programming model: interrupt. | CubeMx | ||
ADC_SingleConversion_TriggerTimer_DMA |
How to use an ADC peripheral to perform a single ADC conversion on a channel at each trigger event from a timer. Converted data is transferred by DMA into a table in RAM memory. | CubeMx | ||
BSP |
BSP_Example |
This example describes how to use the bsp API. | CubeMx | |
CORTEX |
CORTEXM_InterruptSwitch_TrustZone |
How to first use an interrupt in secure application and later assign it to the non-secure application when TrustZone security is activated (Option bit TZEN=1). | CubeMx | |
CORTEXM_MPU |
Presentation of the MPU features. This example configures MPU attributes of different MPU regions then configures a memory area as privileged read-only, and attempts to perform read and write operations in different modes. | CubeMx | ||
CORTEXM_ModePrivilege |
How to modify the Thread mode privilege access and stack. Thread mode is entered on reset or when returning from an exception. | CubeMx | ||
CORTEXM_ProcessStack |
How to modify the Thread mode stack. Thread mode is entered on reset, and can be entered as a result of an exception return. | CubeMx | ||
CORTEXM_SysTick |
How to use the default SysTick configuration with a 1 ms timebase to toggle LEDs. | CubeMx | ||
CRC |
CRC_Bytes_Stream_7bit_CRC |
How to configure the CRC using the HAL API. The CRC (cyclic redundancy check) calculation unit computes 7-bit CRC codes derived from buffers of 8-bit data (bytes). The user-defined generating polynomial is manually set to 0x65, that is, X^7 + X^6 + X^5 + X^2 + 1, as used in the Train Communication Network, IEC 60870-5[17]. | CubeMx | |
CRC_Data_Reversing_16bit_CRC |
How to configure the CRC using the HAL API. The CRC (cyclic redundancy check) calculation unit computes a 16-bit CRC code derived from a buffer of 32-bit data (words). Input and output data reversal features are enabled. The user-defined generating polynomial is manually set to 0x1021, that is, X^16 + X^12 + X^5 + 1 which is the CRC-CCITT generating polynomial. | CubeMx | ||
CRC_Example |
How to configure the CRC using the HAL API. The CRC (cyclic redundancy check) calculation unit computes the CRC code of a given buffer of 32-bit data words, using a fixed generator polynomial (0x4C11DB7). | CubeMx | ||
CRC_UserDefinedPolynomial |
How to configure the CRC using the HAL API. The CRC (cyclic redundancy check) calculation unit computes the 8-bit CRC code for a given buffer of 32-bit data words, based on a user-defined generating polynomial. | CubeMx | ||
CRYP |
CRYP_AESModes |
How to use the CRYP peripheral to encrypt and decrypt data using AES in chaining modes (ECB, CBC, CTR). | CubeMx | |
CRYP_DMA |
How to use the AES peripheral to encrypt and decrypt data using AES 128 Algorithm with ECB chaining mode in DMA mode. | CubeMx | ||
CRYP_GCM_GMAC_CMAC_Suspension |
How to use the CRYP AES peripheral to suspend then resume the AES GCM and GMAC CMAC processing of a message in order to carry out the encryption, decryption or authentication tag computation of a higher-priority message(CMAC). | CubeMx | ||
How to use the Secure AES co-processor (SAES) peripheral to share application keys with AES peripheral. | CubeMx | |||
CRYP_SAES_WrapKey |
How to use the Secure AES co-processor (SAES) peripheral to wrap application keys using hardware secret key DHUK then use it to encrypt in polling mode. | CubeMx | ||
DMA |
DMA_FLASHToRAM |
How to use a DMA to transfer a word data buffer from Flash memory to embedded SRAM through the HAL API. | CubeMx | |
DMA_MemToMem_TrustZone |
How to use HAL DMA to perform memory to memory data transfers over secure and non-secure DMA channels when TrustZone security is activated (Option bit TZEN=1). | CubeMx | ||
FLASH |
FLASH_BlockBased_TrustZone |
How to configure and use the FLASH HAL API to managed block-based security of internal Flash memory between secure and non-secure applications when TrustZone security is activated (Option bit TZEN=1). | CubeMx | |
FLASH_EraseProgram |
How to configure and use the FLASH HAL API to erase and program the internal At the beginning of the main program the HAL_Init() function is called to reset all the peripherals, initialize the Flash interface and the systick. | CubeMx | ||
FLASH_EraseProgram_TrustZone |
How to configure and use the FLASH HAL API to erase and program the internal Flash memory when TrustZone security is activated (Option bit TZEN=1). | CubeMx | ||
FLASH_WriteProtection |
How to configure and use the FLASH HAL API to enable and disable the write protection of the internal Flash memory. | CubeMx | ||
GPIO |
GPIO_EXTI |
How to configure external interrupt lines. | CubeMx | |
GPIO_IOToggle |
How to configure and use GPIOs through the HAL API. | CubeMx | ||
GPIO_IOToggle_TrustZone |
How to use HAL GPIO to toggle secure and unsecure IOs when TrustZone security is activated (Option bit TZEN=1). | CubeMx | ||
GTZC |
GTZC_TZSC_MPCBB_TrustZone |
How to use HAL GTZC MPCBB to build any example with SecureFault detection when TrustZone security is activated (Option bit TZEN=1). | CubeMx | |
HAL |
HAL_TimeBase |
How to customize HAL using a general-purpose timer as main source of time base, instead of Systick. | CubeMx | |
HAL_TimeBase_RTC_WKUP |
How to customize HAL using RTC wakeup as main source of time base, instead of Systick. | CubeMx | ||
HAL_TimeBase_TIM |
How to customize HAL using a general-purpose timer as main source of time base instead of Systick. | CubeMx | ||
HASH |
HASH_HMAC_SHA1MD5 |
How to use the HASH peripheral to hash data with HMAC SHA-1 and HMAC MD5 algorithms. | New | |
HASH_HMAC_SHA256MD5_IT_Suspension |
How to suspend the HMAC digest computation when data are fed in interrupt mode. | CubeMx | ||
HASH_SHA1MD5 |
This example provides a short description of how to use the HASH peripheral to hash data using SHA-1 and MD5 Algorithms. | CubeMx | ||
HASH_SHA1MD5_DMA |
This example provides a short description of how to use the HASH peripheral to hash data using SHA-1 and MD5 Algorithms. | New | ||
HASH_SHA1SHA224_IT_Suspension |
How to suspend the HASH peripheral when data are fed in interrupt mode. | X | ||
HASH_SHA1_DMA_TrustZone |
How to use a secure HASH SHA-1 computation service based on secure DMA channel when TrustZone security is activated (Option bit TZEN=1). | CubeMx | ||
HASH_SHA224SHA256_DMA |
How to use the HASH peripheral to hash data with SHA224 and SHA256 algorithms. | CubeMx | ||
HSEM |
HSEM_ProcessSync |
How to use a HW semaphore to synchronize 2 process. | CubeMx | |
HSEM_ReadLock |
How to enable, take then release semaphore using 2 different Process. | CubeMx | ||
I2C |
I2C_TwoBoards_AdvComIT |
How to handle several I2C data buffer transmission/reception between a master and a slave device, using an interrupt. | CubeMx | |
I2C_TwoBoards_ComDMA |
How to handle I2C data buffer transmission/reception between two boards, via DMA. | CubeMx | ||
I2C_TwoBoards_ComDMA_Autonomous_Master |
How to handle I2C data buffer transmission/reception between two boards, via DMA. | CubeMx | ||
I2C_TwoBoards_ComDMA_Autonomous_Slave |
How to handle I2C data buffer transmission/reception between two boards, via DMA. | CubeMx | ||
I2C_TwoBoards_ComIT |
How to handle I2C data buffer transmission/reception between two boards, using an interrupt. | CubeMx | ||
I2C_TwoBoards_ComPolling |
How to handle I2C data buffer transmission/reception between two boards, in polling mode. | CubeMx | ||
I2C_TwoBoards_RestartAdvComIT |
How to perform multiple I2C data buffer transmission/reception between two boards, in interrupt mode and with restart condition. | CubeMx | ||
I2C_TwoBoards_RestartComIT |
How to handle single I2C data buffer transmission/reception between two boards, in interrupt mode and with restart condition. | CubeMx | ||
I2C_WakeUpFromStop |
How to handle I2C data buffer transmission/reception between two boards, using an interrupt when the device is in Stop mode. | CubeMx | ||
IWDG |
IWDG_Reset |
How to handle the IWDG reload counter and simulate a software fault that generates an MCU IWDG reset after a preset laps of time. | New | |
IWDG_WindowMode |
How to periodically update the IWDG reload counter and simulate a software fault that generates an MCU IWDG reset after a preset laps of time. | CubeMx | ||
LPTIM |
LPTIM_PulseCounter |
How to configure and use, through the LPTIM HAL API, the LPTIM peripheral to count pulses. | CubeMx | |
LPTIM_Timeout |
How to implement, through the HAL LPTIM API, a timeout with the LPTIMER peripheral, to wake up the system from a low-power mode. | CubeMx | ||
PKA |
PKA_ECCscalarMultiplication |
How to use the PKA peripheral to execute ECC scalar multiplication. This allows generating a public key from a private key. | CubeMx | |
PKA_ECCscalarMultiplication_IT |
How to use the PKA peripheral to execute ECC scalar multiplication. This allows generating a public key from a private key in interrupt mode. | CubeMx | ||
PKA_ECDSA_Sign |
How to compute a signed message regarding the Elliptic curve digital signature algorithm (ECDSA). | CubeMx | ||
PKA_ECDSA_Sign_IT |
How to compute a signed message regarding the Elliptic curve digital signature algorithm (ECDSA) in interrupt mode. | CubeMx | ||
PKA_ECDSA_Verify |
How to determine if a given signature is valid regarding the Elliptic curve digital signature algorithm (ECDSA). | CubeMx | ||
PKA_ECDSA_Verify_IT |
How to determine if a given signature is valid regarding the Elliptic curve digital signature algorithm (ECDSA) in interrupt mode. | CubeMx | ||
PKA_ModularExponentiation |
How to use the PKA peripheral to execute modular exponentiation. This allows ciphering/deciphering a text. | CubeMx | ||
PKA_ModularExponentiationCRT |
How to compute the Chinese Remainder Theorem (CRT) optimization. | CubeMx | ||
PKA_ModularExponentiationCRT_IT |
How to compute the Chinese Remainder Theorem (CRT) optimization in interrupt mode. | CubeMx | ||
PKA_ModularExponentiation_IT |
How to use the PKA peripheral to execute modular exponentiation. This allows ciphering/deciphering a text in interrupt mode. | CubeMx | ||
PKA_PointCheck |
How to use the PKA peripheral to determine if a point is on a curve. This allows validating an external public key. | CubeMx | ||
PKA_PointCheck_IT |
How to use the PKA peripheral to determine if a point is on a curve. This allows validating an external public key. | CubeMx | ||
PWR |
PWR_SLEEP |
How to enter the Sleep mode and wake up from this mode by using an interrupt. | CubeMx | |
PWR_STANDBY |
How to enter the Standby mode and wake up from this mode by using an external reset or the WKUP pin. | CubeMx | ||
PWR_STANDBY_RTC |
How to enter the Standby mode and wake-up from this mode by using an external reset or the RTC wakeup timer. | New | ||
PWR_STOP1 |
This example shows how to enter Stop 1 mode and wake up from this mode using an interrupt. | CubeMx | ||
RAMCFG |
RAMCFG_Parity_Error |
How to configure and use the RAMCFG HAL API to enable parity error detection and generate parity error interruption. | CubeMx | |
RAMCFG_WriteProtection |
How to configure and use the RAMCFG HAL API to configure RAMCFG SRAM write protection page. | CubeMx | ||
RCC |
RCC_ClockConfig |
Configuration of the system clock (SYSCLK) and modification of the clock settings in Run mode, using the RCC HAL API. | CubeMx | |
RCC_ClockConfig_TrustZone |
How to configure he system clock (SYSCLK) in Run mode from the secure application upon request from the non-secure application, using the RCC HAL API when TrustZone security is activated (Option bit TZEN=1). | CubeMx | ||
RCC_LSEConfig |
Enabling/disabling of the low-speed external(LSE) RC oscillator (about 32 KHz) at run time, using the RCC HAL API. | CubeMx | ||
RCC_LSIConfig |
How to enable/disable the low-speed internal (LSI) RC oscillator (about 32 KHz) at run time, using the RCC HAL API. | CubeMx | ||
RNG |
RNG_MultiRNG |
Configuration of the RNG using the HAL API. This example uses the RNG to generate 32-bit long random numbers. | CubeMx | |
RNG_MultiRNG_IT |
Configuration of the RNG using the HAL API. This example uses RNG interrupts to generate 32-bit long random numbers. | CubeMx | ||
RTC |
RTC_Alarm |
Configuration and generation of an RTC alarm using the RTC HAL API. | CubeMx | |
RTC_Calendar |
Configuration of the calendar using the RTC HAL API. | CubeMx | ||
RTC_LSI |
Use of the LSI clock source autocalibration to get a precise RTC clock. | CubeMx | ||
RTC_Tamper |
Configuration of the tamper detection with backup registers erase. | CubeMx | ||
RTC_TimeStamp |
Configuration of the RTC HAL API to demonstrate the timestamp feature. | CubeMx | ||
RTC_TrustZone |
How to configure the TrustZone-aware RTC peripheral when TrustZone security is activated (Option bit TZEN=1): some features of the RTC can be secure while the others are non-secure. | CubeMx | ||
SPI |
SPI_FullDuplex_ComDMA_Autonomous_Master |
Data buffer transmission/reception between two boards via SPI using DMA. | CubeMx | |
SPI_FullDuplex_ComDMA_Autonomous_Slave |
Data buffer transmission/reception between two boards via SPI using DMA. | CubeMx | ||
SPI_FullDuplex_ComDMA_Master |
Data buffer transmission/reception between two boards via SPI using DMA. | CubeMx | ||
SPI_FullDuplex_ComDMA_Slave |
Data buffer transmission/reception between two boards via SPI using DMA. | CubeMx | ||
SPI_FullDuplex_ComIT_Master |
Data buffer transmission/reception between two boards via SPI using Interrupt mode. | CubeMx | ||
SPI_FullDuplex_ComIT_Slave |
Data buffer transmission/reception between two boards via SPI using Interrupt mode. | CubeMx | ||
SPI_FullDuplex_ComPolling_Master |
Data buffer transmission/reception between two boards via SPI using Polling mode. | CubeMx | ||
SPI_FullDuplex_ComPolling_Slave |
Data buffer transmission/reception between two boards via SPI using Polling mode. | CubeMx | ||
TIM |
TIM_DMA |
Use of the DMA with TIMER Update request to transfer data from memory to TIMER Capture Compare Register 3 (TIMx_CCR3). | New | |
TIM_DMABurst |
How to update the TIMER channel 1 period and duty cycle using the TIMER GPDMA burst feature. | New | ||
TIM_ExtTriggerSynchro |
This example shows how to synchronize TIM peripherals in cascade mode with an external trigger. | CubeMx | ||
TIM_InputCapture |
How to use the TIM peripheral to measure an external signal frequency. | CubeMx | ||
TIM_OCActive |
Configuration of the TIM peripheral in Output Compare Active mode (when the counter matches the capture/compare register, the corresponding output pin is set to its active state). | CubeMx | ||
TIM_OCInactive |
Configuration of the TIM peripheral in Output Compare Inactive mode with the corresponding Interrupt requests for each channel. | CubeMx | ||
TIM_OCToggle |
Configuration of the TIM peripheral to generate four different signals at four different frequencies. | CubeMx | ||
TIM_OnePulse |
This example shows how to use the TIMER peripheral to generate a single pulse when a rising edge of an external signal is received on the TIMER Input pin. | CubeMx | ||
TIM_PWMInput |
How to use the TIM peripheral to measure the frequency and duty cycle of an external signal. | CubeMx | ||
TIM_PWMOutput |
This example shows how to configure the TIM peripheral in PWM (Pulse Width Modulation) mode. | CubeMx | ||
TIM_TimeBase |
This example shows how to configure the TIM peripheral to generate a time base of one second with the corresponding Interrupt request. | CubeMx | ||
UART |
UART_HyperTerminal_DMA |
UART transmission (transmit/receive) in DMA mode between a board and an HyperTerminal PC application. | CubeMx | |
UART_HyperTerminal_IT |
UART transmission (transmit/receive) in Interrupt mode between a board and an HyperTerminal PC application. | CubeMx | ||
UART_Printf |
Re-routing of the C library printf function to the UART. | CubeMx | ||
UART_TwoBoards_ComDMA |
UART transmission (transmit/receive) in DMA mode between two boards. | New | ||
UART_TwoBoards_ComIT |
UART transmission (transmit/receive) in Interrupt mode between two boards. | New | ||
UART_TwoBoards_ComPolling |
UART transmission (transmit/receive) in Polling mode between two boards. | New | ||
USART |
USART_SlaveMode |
This example describes an USART-SPI communication (transmit/receive) between two boards where the USART is configured as a slave. | CubeMx | |
WWDG |
WWDG_Example |
Configuration of the HAL API to periodically update the WWDG counter and simulate a software fault that generates an MCU WWDG reset when a predefined time period has elapsed. | CubeMx | |
Total number of examples: 112 | 112 | |||
Examples_LL |
ADC |
ADC_AnalogWatchdog_Init |
How to use an ADC peripheral with an ADC analog watchdog to monitor a channel and detect when the corresponding conversion data is outside the window thresholds. | CubeMx |
ADC_ContinuousConversion_TriggerSW_Init |
How to use an ADC peripheral to convert a single channel continuously, from a software start. | CubeMx | ||
ADC_ContinuousConversion_TriggerSW_LowPower_Init |
Use ADC to convert a single channel with ADC low power features auto wait and auto power-off. | New | ||
ADC_Oversampling_Init |
How to use an ADC peripheral with oversampling. | CubeMx | ||
ADC_SingleConversion_TriggerSW_DMA_Init |
How to use an ADC peripheral to perform a single ADC conversion on a channel at each software start. Converted data is transferred by DMA into a table in RAM memory. | New | ||
ADC_SingleConversion_TriggerSW_IT_Init |
How to use ADC to convert a single channel at each SW start, conversion performed using programming model: interrupt. | CubeMx | ||
ADC_SingleConversion_TriggerSW_Init |
How to use ADC to convert a single channel at each SW start, conversion performed using programming model: polling. | CubeMx | ||
ADC_SingleConversion_TriggerTimer_DMA_Init |
How to use an ADC peripheral to perform a single ADC conversion on a channel at each trigger event from a timer. Converted data is transferred by DMA into a table in RAM memory. | New | ||
ADC_TemperatureSensor_Init |
How to use an ADC peripheral to perform a single ADC conversion on the internal temperature sensor and calculate the temperature in degrees Celsius. | CubeMx | ||
CORTEX |
CORTEX_MPU |
Presentation of the MPU features. This example configures MPU attributes of different MPU regions then configures a memory area as privileged read-only, and attempts to perform read and write operations in different modes. | CubeMx | |
CRC |
CRC_CalculateAndCheck |
How to configure the CRC calculation unit to compute a CRC code for a given data buffer, based on a fixed generator polynomial (default value 0x4C11DB7). | CubeMx | |
CRC_UserDefinedPolynomial |
How to configure and use the CRC calculation unit to compute an 8-bit CRC code for a given data buffer, based on a user-defined generating polynomial. | CubeMx | ||
DMA |
DMA_CopyFromFlashToMemory_Init |
How to use a DMA channel to transfer a word data buffer from Flash memory to embedded SRAM. The peripheral initialization uses LL initialization functions to demonstrate LL init usage. | CubeMx | |
EXTI |
EXTI_ToggleLedOnIT_Init |
This example describes how to configure the EXTI and use GPIOs to toggle the user LEDs available on the board when a user button is pressed. This example is based on the STM32WBAxx LL API. Peripheral initialization is done using LL initialization function to demonstrate LL init usage. | CubeMx | |
GPIO |
GPIO_InfiniteLedToggling_Init |
How to configure and use GPIOs to toggle the on-board user LEDs every 250 ms. This example is based on the STM32WBAxx LL API. The peripheral is initialized with LL initialization function to demonstrate LL init usage. | CubeMx | |
HSEM |
HSEM_DualProcess |
How to use the low-layer HSEM API to initialize, lock, and unlock hardware semaphore in the context of two processes accessing the same resource. | CubeMx | |
HSEM_DualProcess_IT |
How to use the low-layer HSEM API to initialize, lock, and unlock hardware semaphore in the context of two processes accessing the same resource. | CubeMx | ||
I2C |
I2C_OneBoard_AdvCommunication_DMAAndIT_Init |
How to exchange data between an I2C master device in DMA mode and an I2C slave device in interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | New | |
I2C_OneBoard_Communication_DMAAndIT_Init |
How to transmit data bytes from an I2C master device using DMA mode to an I2C slave device using interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | CubeMx | ||
I2C_OneBoard_Communication_IT_Init |
How to handle the reception of one data byte from an I2C slave device by an I2C master device. Both devices operate in interrupt mode. The peripheral is initialized with LL initialization function to demonstrate LL init usage. | CubeMx | ||
I2C_OneBoard_Communication_PollingAndIT_Init |
How to transmit data bytes from an I2C master device using polling mode to an I2C slave device using interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | CubeMx | ||
I2C_TwoBoards_MasterRx_SlaveTx_IT_Init |
How to handle the reception of one data byte from an I2C slave device by an I2C master device. Both devices operate in interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | CubeMx | ||
I2C_TwoBoards_MasterTx_SlaveRx_DMA_Init |
How to transmit data bytes from an I2C master device using DMA mode to an I2C slave device using DMA mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | CubeMx | ||
I2C_TwoBoards_MasterTx_SlaveRx_Init |
How to transmit data bytes from an I2C master device using polling mode to an I2C slave device using interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | CubeMx | ||
I2C_TwoBoards_WakeUpFromStop_IT_Init |
How to handle the reception of a data byte from an I2C slave device in Stop0 mode by an I2C master device, both using interrupt mode. The peripheral is initialized with LL unitary service functions to optimize for performance and size. | New | ||
LPTIM |
LPTIM_PulseCounter_Init |
How to use the LPTIM peripheral in counter mode to generate a PWM output signal and update its duty cycle. This example is based on the STM32WBAxx LPTIM LL API. The peripheral is initialized with LL initialization function to demonstrate LL init usage. | CubeMx | |
PKA |
PKA_ECDSA_Sign |
How to use the low-layer PKA API to generate an ECDSA signature. | CubeMx | |
PKA_ModularExponentiation |
How to use the low-layer PKA API to execute RSA modular exponentiation. | New | ||
PWR |
PWR_EnterStandbyMode |
How to enter the Standby mode and wake up from this mode by using an external reset or a wakeup pin. | New | |
PWR_EnterStopMode |
How to enter the Stop 0 mode. | CubeMx | ||
PWR_OptimizedRunMode |
How to increase/decrease frequency and VCORE and how to enter/exit the Low-power run mode. | New | ||
RCC |
RCC_OutputSystemClockOnMCO |
Configuration of MCO pin (PA8) to output the system clock. | CubeMx | |
RCC_UseHSEasSystemClock |
Use of the RCC LL API to start the HSE and use it as system clock. | CubeMx | ||
RCC_UseHSI_PLLasSystemClock |
Modification of the PLL parameters in run time. | CubeMx | ||
RNG |
RNG_GenerateRandomNumbers |
Configuration of the RNG to generate 32-bit long random numbers. | CubeMx | |
RNG_GenerateRandomNumbers_IT |
Configuration of the RNG to generate 32-bit long random numbers using interrupts. | CubeMx | ||
RTC |
RTC_Alarm_Init |
Configuration of the RTC LL API to configure and generate an alarm using the RTC peripheral. The peripheral initialization uses the LL initialization function. | CubeMx | |
RTC_Calendar_Init |
Configuration of the LL API to set the RTC calendar. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
RTC_ExitStandbyWithWakeUpTimer_Init |
How to periodically enter and wake up from STANDBY mode thanks to the RTC Wakeup Timer (WUT). | CubeMx | ||
RTC_Tamper_Init |
Configuration of the Tamper using the RTC LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
RTC_TimeStamp_Init |
Configuration of the Timestamp using the RTC LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
SPI |
SPI_OneBoard_HalfDuplex_DMA_Init |
Configuration of GPIO and SPI peripherals to transmit bytes from an SPI Master device to an SPI Slave device in DMA mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses the LL initialization function to demonstrate LL init usage. | New | |
SPI_OneBoard_HalfDuplex_IT_Init |
Configuration of GPIO and SPI peripherals to transmit bytes from an SPI Master device to an SPI Slave device in Interrupt mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
SPI_TwoBoards_FullDuplex_DMA_Master_Init |
Data buffer transmission and receptionvia SPI using DMA mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
SPI_TwoBoards_FullDuplex_DMA_Slave_Init |
Data buffer transmission and receptionvia SPI using DMA mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
SPI_TwoBoards_FullDuplex_IT_Master_Init |
Data buffer transmission and receptionvia SPI using Interrupt mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
SPI_TwoBoards_FullDuplex_IT_Slave_Init |
Data buffer transmission and receptionvia SPI using Interrupt mode. This example is based on the STM32WBAxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
TIM |
TIM_BreakAndDeadtime_Init |
Configuration of the TIM peripheral to generate three center-aligned PWM and complementary PWM signals, insert a defined deadtime value, use the break feature, and lock the break and dead-time configuration. | CubeMx | |
TIM_InputCapture_Init |
Use of the TIM peripheral to measure a periodic signal frequency provided either by an external signal generator or by another timer instance. This example is based on the STM32WBAxx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
TIM_OutputCompare_Init |
Configuration of the TIM peripheral to generate an output waveform in different output compare modes. This example is based on the STM32WBAxx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
TIM_PWMOutput_Init |
Use of a timer peripheral to generate a PWM output signal and update the PWM duty cycle. This example is based on the STM32WBAxx TIM LL API. The peripheral initialization uses LL initialization function to demonstrate LL Init. | CubeMx | ||
TIM_TimeBase_Init |
Configuration of the TIM peripheral to generate a timebase. This example is based on the STM32WBAxx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
USART |
USART_Communication_Rx_IT_Continuous_Init |
This example shows how to configure GPIO and USART peripheral for continuously receiving characters from HyperTerminal (PC) in Asynchronous mode using Interrupt mode. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | |
USART_Communication_Rx_IT_Continuous_VCP_Init |
This example shows how to configure GPIO and USART peripheral for continuously receiving characters from HyperTerminal (PC) in Asynchronous mode using Interrupt mode. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | ||
USART_Communication_Rx_IT_Init |
This example shows how to configure GPIO and USART peripheral for receiving characters from HyperTerminal (PC) in Asynchronous mode using Interrupt mode. Peripheral initialization is done using LL initialization function to demonstrate LL init usage. | CubeMx | ||
USART_Communication_Rx_IT_VCP_Init |
This example shows how to configure GPIO and USART peripheral for receiving characters from HyperTerminal (PC) in Asynchronous mode using Interrupt mode. Peripheral initialization is done using LL initialization function to demonstrate LL init usage. | CubeMx | ||
USART_Communication_TxRx_DMA_Init |
This example shows how to configure GPIO and USART peripheral to send characters asynchronously to/from an HyperTerminal (PC) in DMA mode. This example is based on STM32WBAxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | New | ||
USART_Communication_Tx_IT_Init |
This example shows how to configure GPIO and USART peripheral to send characters asynchronously to HyperTerminal (PC) in Interrupt mode. This example is based on STM32WBAxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | ||
USART_Communication_Tx_IT_VCP_Init |
This example shows how to configure GPIO and USART peripheral to send characters asynchronously to HyperTerminal (PC) in Interrupt mode. This example is based on STM32WBAxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | ||
USART_Communication_Tx_Init |
This example shows how to configure GPIO and USART peripherals to send characters asynchronously to an HyperTerminal (PC) in Polling mode. If the transfer could not be completed within the allocated time, a timeout allows to exit from the sequence with a Timeout error code. This example is based on STM32WBAxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | ||
USART_Communication_Tx_VCP_Init |
This example shows how to configure GPIO and USART peripherals to send characters asynchronously to an HyperTerminal (PC) in Polling mode. If the transfer could not be completed within the allocated time, a timeout allows to exit from the sequence with a Timeout error code. This example is based on STM32WBAxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). | CubeMx | ||
USART_HardwareFlowControl_Init |
Configuration of GPIO and peripheral to receive characters asynchronously from an HyperTerminal (PC) in Interrupt mode with the Hardware Flow Control feature enabled. This example is based on STM32WBAxx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | CubeMx | ||
USART_SyncCommunication_FullDuplex_DMA_Init |
Configuration of GPIO, USART, DMA and SPI peripherals to transmit bytes between a USART and an SPI (in slave mode) in DMA mode. This example is based on the STM32WBAxx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
USART_SyncCommunication_FullDuplex_IT_Init |
Configuration of GPIO, USART, DMA and SPI peripherals to transmit bytes between a USART and an SPI (in slave mode) in Interrupt mode. This example is based on the STM32WBAxx USART LL API (the SPI uses the DMA to receive/transmit characters sent from/received by the USART). The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). | New | ||
WWDG |
WWDG_RefreshUntilUserEvent_Init |
Configuration of the WWDG to periodically update the counter and generate an MCU WWDG reset when a user button is pressed. The peripheral initialization uses the LL unitary service functions for optimization purposes (performance and size). | CubeMx | |
Total number of examples_ll: 65 | 65 | |||
Examples_MIX |
ADC |
ADC_SingleConversion_TriggerSW_IT |
How to use ADC to convert a single channel at each SW start, conversion performed using programming model: interrupt. | CubeMx |
CRC |
CRC_PolynomialUpdate |
How to use the CRC peripheral through the STM32WBAxx CRC HAL and LL API. | CubeMx | |
DMA |
DMA_FLASHToRAM |
How to use a DMA to transfer a word data buffer from Flash memory to embedded SRAM through the STM32WBAxx DMA HAL and LL API. The LL API is used for performance improvement. | CubeMx | |
I2C |
I2C_OneBoard_ComSlave7_10bits_IT |
How to perform I2C data buffer transmission/reception between one master and two slaves with different address sizes (7-bit or 10-bit). This example uses the STM32WBAxx I2C HAL and LL API (LL API usage for performance improvement) and an interrupt. | CubeMx | |
PWR |
PWR_STOP1 |
How to enter the STOP 1 mode and wake up from this mode by using external reset or wakeup interrupt (all the RCC function calls use RCC LL API for minimizing footprint and maximizing performance). | CubeMx | |
SPI |
SPI_FullDuplex_ComPolling_Master |
Data buffer transmission/reception between two boards via SPI using Polling mode. | New | |
SPI_FullDuplex_ComPolling_Slave |
Data buffer transmission/reception between two boards via SPI using Polling mode. | New | ||
SPI_HalfDuplex_ComPollingIT_Master |
Data buffer transmission/reception between two boards via SPI using Polling (LL driver) and Interrupt modes (HAL driver). | New | ||
SPI_HalfDuplex_ComPollingIT_Slave |
Data buffer transmission/reception between two boards via SPI using Polling (LL driver) and Interrupt modes (HAL driver). | New | ||
TIM |
TIM_PWMInput |
Use of the TIM peripheral to measure an external signal frequency and duty cycle. | CubeMx | |
UART |
UART_HyperTerminal_IT |
Use of a UART to transmit data (transmit/receive) between a board and an HyperTerminal PC application in Interrupt mode. This example describes how to use the USART peripheral through the STM32WBAxx UART HAL and LL API, the LL API being used for performance improvement. | CubeMx | |
UART_HyperTerminal_TxPolling_RxIT |
Use of a UART to transmit data (transmit/receive) between a board and an HyperTerminal PC application both in Polling and Interrupt modes. This example describes how to use the USART peripheral through the STM32WBAxx UART HAL and LL API, the LL API being used for performance improvement. | CubeMx | ||
Total number of examples_mix: 12 | 12 | |||
Applications |
- |
OpenBootloader |
This application exploits OpenBootloader Middleware to demonstrate how to develop an IAP application and how use it. | X |
SBSFU |
The SBSFU provides a Root of Trust solution including Secure Boot and Secure Firmware Update functionalities that is used before executing the application and provides an example of secure service (GPIO toggle) that is isolated from the non-secure application but can be used by the non-secure application at run-time. | X | ||
TFM |
The TFM provides a Root of Trust solution including Secure Boot and Secure Firmware Update functionalities that is used before executing the application and provides TFM secure services that are isolated from the non-secure application but can be used by the non-secure application at run-time. | X | ||
BLE |
BLE_ApplicationInstallManager |
The BLE_ApplicationInstallManager application, associated to a BLE application embedding OTA service, manages the firmware update over the air of a BLE application. | X | |
BLE_Beacon |
How to advertise 4 types of beacon ( tlm, uuid, url, iBeacon ). | CubeMx | ||
BLE_DataThroughput_Client |
How to demonstrate Point-to-Point communication using BLE component (as GATT server or GATT client). | CubeMx | ||
BLE_DataThroughput_Server |
How to demonstrate Point-to-Point communication using BLE component (as GATT server or GATT client). | CubeMx | ||
BLE_HealthThermometer |
How to use the Health Thermometer profile as specified by the BLE SIG. | CubeMx | ||
BLE_HeartRate |
How to use the Heart Rate profile as specified by the BLE SIG. | CubeMx | ||
BLE_HeartRateThreadX |
How to use the Heart Rate profile as specified by the BLE SIG with ThreadX OS. | CubeMx | ||
BLE_HeartRate_ota |
How to use the Heart Rate and OTA profile as specified by the BLE SIG. | CubeMx | ||
BLE_SerialCom_Central |
How to demonstrate Point-to-Point communication using BLE component. | CubeMx | ||
BLE_SerialCom_Peripheral |
How to demonstrate Point-to-Point communication using BLE component. | CubeMx | ||
BLE_TransparentMode |
How to communicate with the STM32CubeMonitor-RF Tool using the transparent mode. | CubeMx | ||
BLE_p2pClient |
Demonstrate STM32WBA acting as BLE central and GATT client. | CubeMx | ||
BLE_p2pClient_Ext |
Demontrates a BLE scanner with connections from an extended and a legacy advertising. | CubeMx | ||
BLE_p2pRouter |
Demonstrate STM32WBA acting at the same time as both: BLE central and peripheral, GATT server and client. | CubeMx | ||
BLE_p2pServer |
How to demonstrate Point-to-Point communication using BLE (as GATT server). | CubeMx | ||
BLE_p2pServerThreadX |
How to demonstrate Point-to-Point communication using BLE (as GATT server). | CubeMx | ||
BLE_p2pServer_Ext |
Demonstrate STM32WBA using BLE stack full version to use several extended advertising sets. | CubeMx | ||
BLE_p2pServer_ota |
Demonstrate STM32WBA acting as BLE peripheral and GATT server. | CubeMx | ||
FileX |
Fx_File_Edit_Standalone |
This application provides an example of FileX stack usage on STM32WBA52CG-Nucleo board, running in standalone mode (without ThreadX). | CubeMx | |
LPM |
Tiny_lpm_3modes |
This example is based on the tiny lpm utility. It shows how the sequencer handles the task waiting for an event. | CubeMx | |
Sequencer |
Sequencer_gpio_toggle |
This example is based on the sequencer utilities. It shows how to use a sequencer task to toggle a GPIO. | CubeMx | |
Sequencer_gpio_toggle_lowpower |
This example is based on the sequencer utilities. | CubeMx | ||
Sequencer_task_pauseresume |
This example is based on the sequencer utilities. It shows how the sequencer handles the task pause/resume mechanism. | CubeMx | ||
Sequencer_task_prio |
This example is based on the sequencer utility. It shows how the sequencer manages task priority. | CubeMx | ||
Sequencer_task_waitevent |
This example is based on the sequencer utility. It shows how the sequencer handles the task waiting for an event. | CubeMx | ||
ThreadX |
Tx_CMSIS_Wrapper |
This application provides an example of CMSIS RTOS adaptation layer for Azure RTOS ThreadX, it shows how to develop an application using the CMSIS RTOS 2 APIs. | X | |
Tx_FreeRTOS_Wrapper |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the FreeRTOS adaptation layer for ThreadX. | X | ||
Tx_LowPower |
This application demonstrates how to configure ThreadX to operate in low power mode. The system spends most of its time in Stop mode, and only wakes up when an external interrupt is triggered. User button B1 is the interrupt source. | CubeMx | ||
Tx_MPU |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the ThreadX Module feature. | X | ||
Tx_SecureLEDToggle_TrustZone |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the ThreadX when the TrustZone feature is enabled (TZEN=1). | CubeMx | ||
Tx_Thread_Creation |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the ThreadX thread management APIs. | CubeMx | ||
Tx_Thread_MsgQueue |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the ThreadX message queue APIs. | CubeMx | ||
Tx_Thread_Sync |
This application provides an example of Azure RTOS ThreadX stack usage, it shows how to develop an application using the ThreadX synchronization APIs. | CubeMx | ||
Total number of applications: 36 | 36 | |||
Total number of projects: 228 | 228 |