Projects Overview

STM32CubeWL Firmware Examples for STM32WLxx Series

The STM32CubeWL 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:

Examples uses only the HAL and BSP drivers (Middleware not used), having as objective to demonstrate the product/peripherals features and usage. The examples are organized per peripheral (a folder for each peripheral, ex. TIM) and offers different complexity level from basic usage of a given peripheral (ex. PWM generation using timer) till integration of several peripherals(use DAC for signals generation with synchronization from TIM6 and DMA). Board resources usage is reduced to the strict minimum.

Examples_LL uses only the LL drivers (HAL and Middleware not used), offering optimum implementation of typical use cases of the peripheral features and configuration procedures. The examples are organized per peripheral (a folder for each peripheral, ex. TIM) and runs exclusively on Nucleo board.

Examples_MIX uses only HAL, BSP and LL drivers (Middleware are not used), having as objective to demonstrate how to use both HAL and LL APIs in the same application, to combine the advantages of both APIs (HAL offers high level and functionalities oriented APIs, with high portability level and hide product or IPs complexity to end user. While LL offers low level APIs at registers level with better optimization). The examples are organized per peripheral (a folder for each peripheral, ex. TIM) and runs exclusively on Nucleo board.

Applications intends to demonstrate the product performance and how to use the different Middleware stacks available. The Applications are organized per Middleware (a folder for each Middleware, ex. USB Host) or product feature that need high level firmware bricks (ex. Audio). Integration Applications that use several Middleware stacks are provided as well.

Demonstrations aims to integrate and run the maximum of peripherals and Middleware stacks to showcase the product features and performance.

A Template project is provided to allow user to quickly build any firmware application on a given board.

The examples are located under STM32Cube_FW_WL_VX.Y.Z\Projects\, and all of them have the same structure:

\Inc folder that contains all header files.

\Src folder for the sources code.

\EWARM, \MDK-ARM and \STM32CubeIDE folders contain the preconfigured project for each toolchain.

A readme describing the example behavior and the environment required to run the example.

To run the example, you have to do the following:

Open the example using your preferred toolchain.

Rebuild all files and load the image into target memory.

Run the example by following the readme instructions.

Note: refer to section "Development Toolchains and Compilers" and "Supported Devices and EVAL, Nucleo and Discovery boards" of the Firmware package release notes to know about the SW/HW environment used for the Firmware development and validation. The correct operation of the provided examples is not guaranteed on some environments, for example when using different compiler or board versions.

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.

The table below contains the list of examples provided within STM32Cube_FW_WL Firmware package.

In this table, the label CubeMX means the projects have been created using STM32CubeMX, the STM32Cube initialization code generator. Those projects can be opened with this tools to modify the projects itself. The others projects are manually created to demonstrate the product features.

UM2643: Getting started with STM32CubeWL for STM32WLxx Series.

UM2642: Description of STM32WLxx HAL drivers.

AN5406: How to build a LoRa® application with STM32CubeWL.

AN5480: How to build a Sigfox™ application with STM32CubeWL.

UM2767: Getting started with the SBSFU of STM32CubeWL.

AN5556: Getting started with STM32WL dual core using IAR™ and Keil®.

UM1721: Developing Applications on STM32Cube with FatFs.

UM1722: Developing Applications on STM32Cube with RTOS.

Level

Module Name

Project Name

Description

NUCLEO-WL55JC1

NUCLEO-WL55JC

B-WL5M-SUBG1

Templates

DualCore

This projects provides a reference template that can be used to build any Dual Core (CM4 / CM0) firmware application.

CubeMx

New

SingleCore

This projects provides a reference template that can be used to build any Single Core (CM4) firmware application.

CubeMx

New

Total number of templates: 4

Templates_LL

DualCore

This projects provides a reference template through the LL API that can be used to build any Dual Core (CM4 / CM0) firmware application.

CubeMx

New

SingleCore

This projects provides a reference template through the LL API that can be used to build any Single Core (CM4) firmware application.

CubeMx

New

Total number of templates_ll: 4

Examples

ADC

ADC_AnalogWatchdog

How to use the ADC peripheral to perform conversions with an analog watchdog and out-of-window interrupts enabled.

CubeMx

ADC_MultiChannelSingleConversion

Use ADC to convert a several channels using sequencer in discontinuous mode, conversion data are transferred by DMA into an array, indefinitely (circular mode).

CubeMx

ADC_Oversampling

Use ADC to convert a single channel but using oversampling feature to increase resolution.

CubeMx

ADC_SingleConversion_TriggerSW_IT

Use ADC to convert a single channel at each SW start, conversion performed using programming model: interrupt Example configuration: ADC is configured to convert a single channel, in single conversion mode, from SW trigger.

CubeMx

ADC_SingleConversion_TriggerTimer_DMA

Use ADC to convert a single channel at each trig from timer, conversion data are transferred by DMA into an array, indefinitely (circular mode).

CubeMx

BSP

BSP_Example

How to use the different BSP drivers of external devices mounted on : B-WL5M-SUBG1 board.

New

COMP

COMP_CompareGpioVsVrefInt_IT

How to configure the COMP peripheral to compare the external voltage applied on a specific pin with the Internal Voltage Reference.

CubeMx

COMP_CompareGpioVsVrefInt_Window_IT

CubeMx

CORTEX

CORTEXM_MPU

Presentation of the MPU feature. This example 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

DAC

DAC_SignalsGeneration

How to use the DAC peripheral to generate several signals using the DMA controller and the DAC internal wave generator.

CubeMx

DAC_SimpleConversion

How to use the DAC peripheral to do a simple conversion.

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_MUXSYNC

How to use the DMA with the DMAMUX to synchronize a transfer with the LPTIM1 output signal. USART1 is used in DMA synchronized mode to send a countdown from 10 to 00, with a period of 2 seconds.

CubeMx

DMA_MUX_RequestGen

How to use the DMA with the DMAMUX request generator to generate DMA transfer requests upon an External line 0 rising edge signal.

CubeMx

DMA_SecureTransfer_DualCore

How to configure DMA to perform a data transfer from secured area to unsecure area.

CubeMx

FLASH

FLASH_EraseProgram

How to configure and use the FLASH HAL API to erase and program the internal Flash memory.

CubeMx

FLASH_FastProgram

How to configure and use the FLASH HAL API to erase and fast program the internal Flash memory.

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

GTZC

GTZC_GlobalSecurityConfiguration_DualCore

How to configure Flash option bytes and GTZC to fully secure all resources from unsecured accesses.

GTZC_MemoryWatermarkProtection_DualCore

How to protect secure memory area from unprivileged access and set up illegal access notification.

CubeMx

GTZC_PeripheralProtection_DualCore

How to secure peripheral IP access and set up illegal access notification.

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_ALARM

How to customize HAL using RTC alarm 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

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

HSEM_Sync_DualCore

How to synchronise 2 cpus using HSEM peripherals to access safely a shared resource.

CubeMx

I2C

I2C_TwoBoards_ComDMA

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

I2C_WakeUpFromStop2

How to handle I2C data buffer transmission/reception between two boards, using an interrupt when the device is in Stop 2 mode.

CubeMx

IPCC

IPCC_HalfDuplexMode_DualCore

How to transfer data between two processors using IPCC Half Duplex channel mode.

CubeMx

IPCC_SimplexMode_DualCore

How to transfer data between two processors using IPCC Simplex channel 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.

CubeMx

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_PWMExternalClock

How to configure and use, through the HAL LPTIM API, the LPTIM peripheral using an external counter clock, to generate a PWM signal at the lowest power consumption.

CubeMx

LPTIM_PWM_LSE

How to configure and use, through the HAL LPTIM API, the LPTIM peripheral using LSE as counter clock, to generate a PWM signal, in a low-power mode.

CubeMx

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_LPRUN

How to enter and exit the Low-power run mode.

CubeMx

PWR_LPSLEEP

How to enter the Low-power sleep mode and wake up from this mode by using an interrupt.

CubeMx

PWR_PVD

How to configure the programmable voltage detector by using an external interrupt line. External DC supply must be used to supply Vdd.

CubeMx

PWR_SMPS

How to configure and use SMPS through the HAL API.

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.

CubeMx

PWR_STOP2_RTC

How to enter the Stop 2 mode and wake-up from this mode using an external reset or RTC wakeup timer.

CubeMx

PWR_SecurityIllegalAccess_DualCore

How to manage illegal access in multicore program and low-power modes.

CubeMx

PWR_Standby_DualCore

How to manage system low-power mode Standby and each CPU low-power modes in multicore program.

CubeMx

PWR_Stop2_DualCore

How to manage system low-power mode Stop and each CPU low-power modes in multicore program.

CubeMx

PWR_Stop2_PeripheralNoRetention

How to use low-power mode Stop2 and peripherals not featuring retention of configuration.

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_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_Alarm_DualCore

This multicore project shows how CPU1 (CM4) uses the Alarm A and CPU2 (CM0) uses Alarm B.

CubeMx

RTC_Binary

Configuration of the binary mode with binary alarm A and reading of the time.

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

SPI

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

SUBGHZ

SUBGHZ_Tx_Mode

This example shows how to configure the SUBGHZ peripheral to set the SUBGHZ Radio in Tx 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).

CubeMx

TIM_DMABurst

How to update the TIMER channel 1 period and duty cycle using the TIMER DMA burst feature.

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

LPUART_WakeUpFromStop

Configuration of an LPUART to wake up the MCU from Stop mode when a given stimulus is received.

CubeMx

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_ReceptionToIdle_CircularDMA

How to use the HAL UART API for reception to IDLE event in circular DMA mode.

CubeMx

UART_TwoBoards_ComDMA

UART transmission (transmit/receive) in DMA mode between two boards.

CubeMx

UART_TwoBoards_ComIT

UART transmission (transmit/receive) in Interrupt mode between two boards.

CubeMx

UART_TwoBoards_ComPolling

UART transmission (transmit/receive) in Polling mode between two boards.

CubeMx

UART_WakeUpFromStopUsingFIFO

Configuration of an UART to wake up the MCU from Stop mode with a FIFO level when a given stimulus is received.

CubeMx

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: 117

116

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 perform continuous ADC conversions on a channel, from a software start.

CubeMx

ADC_ContinuousConversion_TriggerSW_LowPower_Init

How to use an ADC peripheral with ADC low-power features.

CubeMx

ADC_Oversampling_Init

How to use an ADC peripheral with ADC 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. This example uses the DMA programming model (for polling or interrupt programming models, refer to other examples).

CubeMx

ADC_SingleConversion_TriggerSW_IT_Init

How to use an ADC peripheral to perform a single ADC conversion on a channel, at each software start. This example uses the interrupt programming model (for polling or DMA programming models, please refer to other examples).

CubeMx

ADC_SingleConversion_TriggerSW_Init

How to use an ADC peripheral to perform a single ADC conversion on a channel at each software start. This example uses the polling programming model (for interrupt or DMA programming models, please refer to other examples).

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 indefinitely transferred by DMA into a table (circular mode).

CubeMx

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

COMP

COMP_CompareGpioVsVrefInt_IT_Init

How to use a comparator peripheral to compare a voltage level applied on a GPIO pin to the the internal voltage reference (VREFINT), in interrupt mode. This example is based on the STM32WLxx COMP LL API. The peripheral initialization uses the LL initialization function to demonstrate LL init usage.

CubeMx

COMP_CompareGpioVsVrefInt_OutputGpio_Init

How to use a comparator peripheral to compare a voltage level applied on a GPIO pin to the internal voltage reference (VREFINT). The comparator output is connected to a GPIO. This example is based on the STM32WLxx COMP LL API.

CubeMx

COMP_CompareGpioVsVrefInt_Window_IT_Init

How to use a pair of comparator peripherals to compare a voltage level applied on a GPIO pin to two thresholds: the internal voltage reference (VREFINT) and a fraction of the internal voltage reference (VREFINT/2), in interrupt mode. This example is based on the STM32WLxx COMP LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

CORTEX

CORTEX_MPU

Presentation of the MPU feature. This example 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). The peripheral initialization is done using LL unitary service functions for optimization purposes (performance and size).

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. The peripheral initialization is done using LL unitary service functions for optimization purposes (performance and size).

CubeMx

DAC

DAC_GenerateConstantSignal_TriggerSW_Init

How to use the DAC peripheral to generate a constant voltage signal. This example is based on the STM32WLxx DAC LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

DAC_GenerateConstantSignal_TriggerSW_LP_Init

How to use the DAC peripheral to generate a constant voltage signal with the DAC low-power feature sample-and-hold. To be effective, a capacitor must be connected to the DAC channel output and the sample-and-hold timings must be tuned depending on the capacitor value. This example is based on the STM32WLxx DAC LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

DAC_GenerateWaveform_TriggerHW_Init

How to use the DAC peripheral to generate a voltage waveform from a digital data stream transferred by DMA. This example is based on the STM32WLxx DAC LL API. The peripheral initialization uses LL initialization functions to demonstrate LL init usage.

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 STM32WLxx 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 STM32WLxx 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.

CubeMx

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

CubeMx

I2C_TwoBoards_WakeUpFromStop2_IT_Init

How to handle the reception of a data byte from an I2C slave device in Stop 2 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.

CubeMx

I2C_TwoBoards_WakeUpFromStop_IT_Init

How to handle the reception of a data byte from an I2C slave device in Stop 1 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.

CubeMx

IPCC

IPCC_SimplexMode_DualCore

How to transfer data between two processors using IPCC Simplex channel mode.

CubeMx

IWDG

IWDG_RefreshUntilUserEvent_Init

How to configure the IWDG peripheral to ensure periodical counter update and generate an MCU IWDG reset when a User push-button (B1) is pressed. The peripheral is initialized with LL unitary service functions to optimize for performance and size.

CubeMx

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 STM32WLxx LPTIM LL API. The peripheral is initialized with LL initialization function to demonstrate LL init usage.

CubeMx

LPUART

LPUART_WakeUpFromStop2_Init

Configuration of GPIO and LPUART peripherals to allow characters received on LPUART_RX pin to wake up the MCU from low-power mode. This example is based on the LPUART LL API. The peripheral initialization uses LL initialization function to demonstrate LL init usage.

CubeMx

LPUART_WakeUpFromStop_Init

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.

CubeMx

PWR

PWR_EnterStandbyMode

How to enter the Standby mode and wake up from this mode by using an external reset or a wakeup pin.

CubeMx

PWR_EnterStopMode

How to enter the Stop 2 mode.

CubeMx

PWR_OptimizedRunMode

How to increase/decrease frequency and VCORE and how to enter/exit the Low-power run mode.

CubeMx

RCC

RCC_HWAutoMSICalibration

Use of the MSI clock source hardware autocalibration and LSE clock (PLL mode) to obtain a precise MSI clock.

CubeMx

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. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

RNG_GenerateRandomNumbers_IT

Configuration of the RNG to generate 32-bit long random numbers using interrupts. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

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_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 STM32WLxx SPI LL API. The peripheral initialization uses the LL initialization function to demonstrate LL init usage.

CubeMx

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 STM32WLxx 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 STM32WLxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

SPI_TwoBoards_FullDuplex_DMA_Slave_Init

CubeMx

SPI_TwoBoards_FullDuplex_IT_Master_Init

Data buffer transmission and receptionvia SPI using Interrupt mode. This example is based on the STM32WLxx SPI LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

SPI_TwoBoards_FullDuplex_IT_Slave_Init

CubeMx

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_DMA_Init

Use of the DMA with a timer update request to transfer data from memory to Timer Capture Compare Register 3 (TIMx_CCR3). This example is based on the STM32WLxx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

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 STM32WLxx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

TIM_OnePulse_Init

Configuration of a timer to generate a positive pulse in Output Compare mode with a length of tPULSE and after a delay of tDELAY. This example is based on the STM32WLxx TIM LL API. The peripheral initialization uses LL initialization function to demonstrate LL Init.

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

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

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 STM32WLxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size).

CubeMx

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

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 STM32WLxx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size).

CubeMx

USART_Communication_Tx_VCP_Init

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 STM32WLxx 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 STM32WLxx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size).

CubeMx

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 STM32WLxx 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).

CubeMx

USART_WakeUpFromStop1_Init

Configuration of GPIO and USART1 peripherals to allow the characters received on USART_RX pin to wake up the MCU from low-power mode.

CubeMx

USART_WakeUpFromStop_Init

Configuration of GPIO and USART1 peripherals to allow the characters received on USART_RX pin to wake up the MCU from low-power mode.

CubeMx

UTILS

UTILS_ConfigureSystemClock

Use of UTILS LL API to configure the system clock using PLL with HSI as source clock.

CubeMx

UTILS_ReadDeviceInfo

This example reads the UID, Device ID and Revision ID and saves them into a global information buffer.

CubeMx

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: 82

Examples_MIX

ADC

ADC_SingleConversion_TriggerSW_IT

How to use the ADC to perform a single ADC channel conversion at each software start. This example uses the interrupt programming model (for polling and DMA programming models, please refer to other examples). It is based on the STM32WLxx ADC HAL and LL API. The LL API is used for performance improvement.

CubeMx

CRC

CRC_PolynomialUpdate

How to use the CRC peripheral through the STM32WLxx 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 STM32WLxx 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 STM32WLxx 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.

CubeMx

SPI_FullDuplex_ComPolling_Slave

Data buffer transmission/reception between two boards via SPI using Polling mode.

CubeMx

SPI_HalfDuplex_ComPollingIT_Master

Data buffer transmission/reception between two boards via SPI using Polling (LL driver) and Interrupt modes (HAL driver).

CubeMx

SPI_HalfDuplex_ComPollingIT_Slave

Data buffer transmission/reception between two boards via SPI using Polling (LL driver) and Interrupt modes (HAL driver).

CubeMx

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 STM32WLxx 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 STM32WLxx UART HAL and LL API, the LL API being used for performance improvement.

CubeMx

Total number of examples_mix: 12

Applications

BFU_1_Slot

1_Image_BFU

The Boot (B) and Firmware Update (FU) solution allows the update of the STM32 microcontroller built-in program with new firmware versions, adding new features and correcting potential issues. The update process is performed in a secure way to prevent unauthorized updates.

1_Image_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

1_Image_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Boot & Firmware Update application (BFU).

1_Image_UserApp

This application demonstrates firmware download capabilities and provides a set of functions to test the active protections offered by Secure Boot and Secure Engine.

BFU_2_Slots

1_Image_BFU

1_Image_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

1_Image_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Boot & Firmware Update application (BFU).

1_Image_UserApp

This application demonstrates firmware download capabilities and provides a set of functions to test the active protections offered by Secure Boot and Secure Engine.

FatFs

FatFs_uSD_Standalone

How to use STM32Cube firmware with FatFs middleware component as a generic FAT file system module. This example develops an application that exploits FatFs features to configure a microSD drive.

FreeRTOS

FreeRTOS_HSEM_DualCore

How to synchronise 2 cpus using HSEM peripherals and CMSISOS2.0 RTOS API application.

FreeRTOS_LowPower

How to enter and exit low-power mode with CMSIS RTOS API.

CubeMx

FreeRTOS_Queues

How to use message queues with CMSIS RTOS API.

CubeMx

FreeRTOS_Semaphore

How to use semaphores with CMSIS RTOS API.

CubeMx

FreeRTOS_StopMode

How to enter and exit low-power mode with CMSISOS2.0 RTOS API.

CubeMx

FreeRTOS_ThreadCreation

How to implement thread creation using CMSIS RTOS API.

CubeMx

FreeRTOS_ThreadFlags

How to use thread flags with CMSIS_RTOS2 API.

CubeMx

FreeRTOS_Timers

How to use timers of CMSIS RTOS API.

CubeMx

KMS

KMS_Blob_Binary

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

KMS_Blob_Example

How to use the KMS middleware provisionning capabilities (C_STM_ImportBlob API).

CubeMx

KMS_Derive_Key

How to use the KMS middleware to create a derivated AES key.

CubeMx

KMS_Embedded_AES_Keys

How to use the KMS middleware to encrypt and decrypt message with AES key.

CubeMx

KMS_Embedded_RSA_Key

How to use the KMS middleware to sign and verify a message with RSA key.

CubeMx

LoRaWAN

LoRaWAN_AT_Slave

This directory contains a set of source files that implements a LoRa application modem that is controlled though AT command interface over UART by an external host, like a computer executing a terminal.

CubeMx

New

LoRaWAN_AT_Slave_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application modem that is controlled though AT command interface over UART by an external host, like a computer executing a terminal.

CubeMx

LoRaWAN_End_Node

This directory contains a set of source files that implements a LoRa application device sending sensors data to LoRa Network server.

CubeMx

New

LoRaWAN_End_Node_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application device sending sensors data to LoRa Network server.

CubeMx

New

LoRaWAN_End_Node_DualCoreFreeRTOS

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application device sending sensors data to LoRa Network server with FreeRTOS Task scheduler on CM4.

CubeMx

LoRaWAN_End_Node_FreeRTOS

This directory contains a set of source files that implements a LoRa application device sending sensors data to LoRa Network server with FreeRTOS Task scheduler.

CubeMx

LoRaWAN_FUOTA

1_Image_BFU

1_Image_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

1_Image_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Boot & Firmware Update application (BFU).

LoRaWAN_End_Node

This directory contains a set of source files that implements a LoRa application device with firmware update over the air download capabilities.

LoRaWAN_FUOTA_DualCore

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

2_Images_SBSFU

The Secure Boot (SB) and Secure Firmware Update (SFU) solution allows the update of the STM32 microcontroller built-in program with new firmware versions, adding new features and correcting potential issues. The update process is performed in a secure way to prevent unauthorized updates and access to confidential on-device data such as secret code and firmware encryption key.

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

LoRaWAN_End_Node_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application device with firmware update over the air download capabilities.

LoRaWAN_FUOTA_DualCore_ExtFlash

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

New

2_Images_SBSFU

New

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

New

LoRaWAN_End_Node_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application device with firmware update over the air download capabilities in using the External Flash as download slot.

New

LoRaWAN_SBSFU_1_Slot_DualCore

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

2_Images_SBSFU

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

LoRaWAN_End_Node_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) LoRa application device with security environment offered by Secure Boot and Secure Engine.

SBSFU_1_Slot_DualCore

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

2_Images_SBSFU

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

2_Images_UserApp_M0Plus

This application demonstrates firmware download capabilities and provides a set of functions to test the active protections offered by Secure Boot and Secure Engine.

2_Images_UserApp_M4

This application demonstrates firmware download capabilities.

SBSFU_2_Slots_DualCore

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

2_Images_SBSFU

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

2_Images_UserApp_M0Plus

This application demonstrates firmware download capabilities and provides a set of functions to test the active protections offered by Secure Boot and Secure Engine.

2_Images_UserApp_M4

This application demonstrates firmware download capabilities.

Sigfox

Sigfox_AT_Slave

This directory contains a set of source files that implements a Sigfox application modem that is controlled though AT command interface over UART by an external host, like a computer executing a terminal.

CubeMx

New

Sigfox_AT_Slave_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) Sigfox application modem that is controlled though AT command interface over UART by an external host, like a computer executing a terminal.

CubeMx

Sigfox_PushButton

This directory contains a set of source files that implements an example of a Sigfox object sending temperature and Battery Level to a Sigfox Network.

CubeMx

New

Sigfox_PushButton_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) Sigfox application example of a Sigfox object sending temperature and Battery Level to a Sigfox Network.

CubeMx

New

Sigfox_SBSFU_1_Slot_DualCore

2_Images_KMS_Blob

This application is used to generate Key Management Services Blob binary file to be downloaded with KMS through the ImportBlob() API.

2_Images_SBSFU

2_Images_SECoreBin

This application is used to generate Secure Engine Core binary file to be linked with Secure Boot & Secure Firmware Update application (SBSFU).

Sigfox_PushButton_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) Sigfox application device with security environment offered by Secure Boot and Secure Engine.

SubGHz_Phy

SubGHz_Phy_AT_Slave

This directory contains a set of source files that implements RF TEST controlled though AT command interface over UART by an external host.

New

SubGHz_Phy_LrFhss

This directory contains a set of source files that implements a LR-FHSS tests application (Tx only).

New

SubGHz_Phy_Per

This directory contains a set of source files that implements a PER (Packet Error Rate) tests application with IBM whitening between one Tx device and one Rx device.

CubeMx

New

SubGHz_Phy_PingPong

This directory contains a set of source files that implements a Ping-Pong application between two PingPong Devices.

CubeMx

SubGHz_Phy_PingPong_DualCore

This directory contains a set of source files that implements a Dual Core (CM4 / CM0) Ping-Pong application between two PingPong Devices.

CubeMx

New

Total number of applications: 75

Demonstrations

LocalNetwork

LocalNetwork_Concentrator

This directory contains a set of source files that implements a Concentrator sending Beacon to administrate a Network of up to 14 sensors and receives each connected Sensor's data.

LocalNetwork_Sensor

This directory contains a set of source files that implements Sensor sending Sensor data (based on the Internal Temperature Sensor and VBat information) to the demo concentrator.

LocalNetwork_Sensor

Sensor

This directory contains a set of source files that implements Sensor sending Sensor data (based on all sensors available on the B-WL5M-SUBG1 board) to the demo concentrator.

New

Total number of demonstrations: 3

Total number of projects: 297

271