STM32CubeG0 Firmware Examples for STM32G0xx Series

The STM32CubeG0 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_G0_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.

The table below contains the list of examples provided within STM32Cube_FW_G0 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.

Reference materials available on www.st.com/stm32cubefw

Level Module Name Project Name Description STM32G0C1E-EV STM32G081B-EVAL STM32G071B-DISCO STM32G0316-DISCO NUCLEO-G0B1RE NUCLEO-G071RB NUCLEO-G070RB NUCLEO-G031K8

Templates

-

Starter project

This projects provides a reference template that can be used to build any firmware application. CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx
Total number of templates: 8 1 1 1 1 1 1 1 1

Templates_LL

-

Starter project

This projects provides a reference template through the LL API that can be used to build any firmware application. CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx
Total number of templates_ll: 8 1 1 1 1 1 1 1 1

Examples

-

BSP

This example provides a description of how to use the different BSP drivers of the STM32G71RB Discovery board. - - X - - - - -

BSP_USBPD

This example provides a description of how to use the different BSP drivers. X X - - - - - -

ADC

ADC_AnalogWatchdog

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

ADC_ContinuousConversion_TriggerSW

This example provides a short description of how to use the ADC peripheral to perform conversions in continuous mode. - - - CubeMx - - - CubeMx

ADC_MultiChannelSingleConversion

Use ADC to convert several channels using sequencer in discontinuous mode, conversion data are transferred by DMA into an array, indefinitely (circular mode). - CubeMx - - CubeMx CubeMx 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

This example provides a description of how to use the different BSP drivers. CubeMx CubeMx - - - - - -

CEC

CEC_DataExchange_Device_1

This example shows how to configure and use the CEC peripheral to receive and transmit messages. CubeMx CubeMx - - - - - -

CEC_DataExchange_Device_2

This example shows how to configure and use the CEC peripheral to receive and transmit messages. CubeMx CubeMx - - - - - -

CEC_ListenMode_Device_1

This example shows how to configure and use the CEC peripheral to receive and transmit messages between two boards while a third one (the spy device) listens but doesn't acknowledge the received messages. CubeMx CubeMx - - - - - -

CEC_ListenMode_Device_2

This example shows how to configure and use the CEC peripheral to receive and transmit messages between two boards while a third one (the spy device) listens but doesn't acknowledge the received messages. CubeMx CubeMx - - - - - -

CEC_ListenMode_Device_3

This example shows how to configure and use the CEC peripheral to receive and transmit messages between two boards while a third one (the spy device) listens but doesn't acknowledge the received messages. CubeMx CubeMx - - - - - -

CEC_MultiAddress_Device_1

This example shows how to configure and use the CEC peripheral to receive and transmit messages in the case where one device supports two distinct logical addresses at the same time. CubeMx CubeMx - - - - - -

CEC_MultiAddress_Device_2

This example shows how to configure and use the CEC peripheral to receive and transmit messages in the case where one device supports two distinct logical addresses at the same time. CubeMx CubeMx - - - - - -

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

COMP_CompareGpioVsVrefInt_Window_IT

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

CORTEXM_SysTick

How to use the default SysTick configuration with a 1 ms timebase to toggle LEDs. CubeMx - - - CubeMx 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 CubeMx CubeMx - CubeMx CubeMx 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 8-bit data (bytes). 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 CubeMx CubeMx - CubeMx CubeMx 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 CubeMx CubeMx - - CubeMx 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 CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx

CRYP

CRYP_AESModes

How to use the CRYP peripheral to encrypt and decrypt data using AES in chaining modes (ECB, CBC, CTR). CubeMx CubeMx - - - - - -

CRYP_AESModes_Suspension

How to use the CRYP peripheral to suspend then resume a ciphering processing. - CubeMx - - - - - -

CRYP_DMA

How to use the CRYP peripheral to encrypt and decrypt data using the AES-128 algorithm with ECB chaining mode in DMA mode. - CubeMx - - - - - -

CRYP_GCM_GMAC_CCM_Modes

How to use the CRYP peripheral to encrypt data and generate authentication tags using GCM/GMAC/CCM modes. - CubeMx - - - - - -

CRYP_GCM_Suspension

How to use the CRYP peripheral to suspend then resume an authentication ciphering processing. - 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 - - - CubeMx 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 - - - CubeMx 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 - - - CubeMx CubeMx

CORTEXM_SysTick

How to use the default SysTick configuration with a 1 ms timebase to toggle LEDs. - - CubeMx CubeMx - - CubeMx 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 - - CubeMx CubeMx - -

DAC_SimpleConversion

How to use the DAC peripheral to do a simple conversion. CubeMx CubeMx - - - 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 CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx

FDCAN

FDCAN_Classic_Frame_Networking

How to configure the FDCAN peripheral to send and receive Classic CAN frames. CubeMx - - - - - - -

FDCAN_Com_IT_2_BOARDS

How to achieve Interrupt Process Communication between two FDCAN units. CubeMx - - - - - - -

FDCAN_Com_polling_2_BOARDS

How to achieve Polling Process Communication between two FDCAN units. CubeMx - - - - - - -

FDCAN_Loopback

How to configure the FDCAN to operate in loopback mode. CubeMx - - - - - - -

FLASH

FLASH_EraseProgram

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

GPIO

GPIO_EXTI

How to configure external interrupt lines. - - - - CubeMx CubeMx CubeMx -

GPIO_IOToggle

How to configure and use GPIOs through the HAL API. CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx

HAL

HAL_TimeBase

How to customize HAL using a general-purpose timer as main source of time base, instead of Systick. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

HAL_TimeBase_RTC_ALARM

How to customize HAL using RTC alarm as main source of time base, instead of Systick. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

HAL_TimeBase_RTC_WKUP

How to customize HAL using RTC wakeup as main source of time base, instead of Systick. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

HAL_TimeBase_TIM

How to customize HAL using a general-purpose timer as main source of time base instead of Systick. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

I2C

I2C_EEPROM

How to handle I2C data buffer transmission/reception with DMA. In the example, the device communicates with an I2C EEPROM memory. - X - - - - - -

I2C_TwoBoards_AdvComIT

How to handle I2C data buffer transmission/reception between two boards, using an interrupt. - - - - - CubeMx CubeMx CubeMx

I2C_TwoBoards_ComDMA

How to handle I2C data buffer transmission/reception between two boards, via DMA. CubeMx CubeMx - - - CubeMx CubeMx CubeMx

I2C_TwoBoards_ComIT

How to handle I2C data buffer transmission/reception between two boards, using an interrupt. - CubeMx - - - CubeMx CubeMx CubeMx

I2C_TwoBoards_ComPolling

How to handle I2C data buffer transmission/reception between two boards, in polling mode. - CubeMx - - - CubeMx CubeMx CubeMx

I2C_TwoBoards_RestartAdvComIT

How to perform multiple I2C data buffer transmission/reception between two boards, in interrupt mode and with restart condition. - - - - - CubeMx CubeMx CubeMx

I2C_TwoBoards_RestartComIT

How to handle single I2C data buffer transmission/reception between two boards, in interrupt mode and with restart condition. - - - - - CubeMx CubeMx 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 CubeMx CubeMx 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 CubeMx - CubeMx CubeMx CubeMx 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 CubeMx CubeMx CubeMx - CubeMx CubeMx 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 - - - 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 CubeMx - - - - - -

LPTIM_PulseCounter

How to configure and use, through the LPTIM HAL API, the LPTIM peripheral to count pulses. CubeMx CubeMx - - CubeMx CubeMx - 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 - - - CubeMx - -

PWR

PWR_LPRUN

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

PWR_LPSLEEP

How to enter the Low-power sleep mode and wake up from this mode by using an interrupt. CubeMx CubeMx - - CubeMx CubeMx 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 CubeMx - - CubeMx CubeMx - -

PWR_SLEEP

How to enter the Sleep mode and wake up from this mode by using an interrupt. CubeMx CubeMx - - CubeMx CubeMx 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 CubeMx - - CubeMx CubeMx 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 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 CubeMx CubeMx -

RCC_LSIConfig

Enabling/disabling of the low-speed internal (LSI) RC oscillator (about 32 KHz) at run time, using the RCC HAL API. - - - CubeMx CubeMx CubeMx CubeMx CubeMx

RCC_SwitchClock

Switch of the system clock (SYSCLK) from Low frequency clock to high frequency clock, using the RCC HAL API. CubeMx CubeMx 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 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 - CubeMx - CubeMx CubeMx CubeMx

RTC_Calendar

Configuration of the calendar using the RTC HAL API. - CubeMx - - - CubeMx CubeMx -

RTC_InternalTimeStamp

Demonstration the internal timestamp feature using the RTC HAL API. - CubeMx - - - - - -

RTC_LSI

Use of the LSI clock source autocalibration to get a precise RTC clock. - CubeMx - - - CubeMx CubeMx -

RTC_LowPower_STANDBY

How to enter STANDBY mode and wake up from this mode using the RTC alarm event. CubeMx CubeMx - - CubeMx - - -

RTC_Tamper

Configuration of the RTC HAL API to write/read data to/from RTC Backup registers. - X - - CubeMx X X -

RTC_TimeStamp

Configuration of the RTC HAL API to demonstrate the timestamp feature. CubeMx CubeMx - - - CubeMx CubeMx -

SMBUS

SMBUS_TSENSOR

This example shows how to ensure SMBUS Data buffer transmission and reception with IT. The communication is done with a SMBUS temperature sensor. CubeMx CubeMx - - - - - -

SPI

SPI_FullDuplex_ComDMA_Master

Data buffer transmission/reception between two boards via SPI using DMA. - CubeMx - - CubeMx CubeMx CubeMx CubeMx

SPI_FullDuplex_ComDMA_Slave

Data buffer transmission/reception between two boards via SPI using DMA. - CubeMx - - CubeMx CubeMx CubeMx CubeMx

SPI_FullDuplex_ComIT_Master

Data buffer transmission/reception between two boards via SPI using Interrupt mode. - CubeMx - - - CubeMx CubeMx CubeMx

SPI_FullDuplex_ComIT_Slave

Data buffer transmission/reception between two boards via SPI using Interrupt mode. - CubeMx - - - CubeMx CubeMx CubeMx

SPI_FullDuplex_ComPolling_Master

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

SPI_FullDuplex_ComPolling_Slave

Data buffer transmission/reception between two boards via SPI using Polling mode. CubeMx CubeMx - - - CubeMx CubeMx 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 - - CubeMx CubeMx CubeMx -

TIM_DMABurst

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

TIM_ExtTriggerSynchro

This example shows how to synchronize TIM peripherals in cascade mode with an external trigger. - CubeMx - - - CubeMx CubeMx -

TIM_InputCapture

How to use the TIM peripheral to measure an external signal frequency. - CubeMx - - - CubeMx 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 - - - CubeMx CubeMx -

TIM_OCInactive

Configuration of the TIM peripheral in Output Compare Inactive mode with the corresponding Interrupt requests for each channel. - CubeMx - - - CubeMx CubeMx -

TIM_OCToggle

Configuration of the TIM peripheral to generate four different signals at four different frequencies. - CubeMx - - - CubeMx CubeMx -

TIM_OnePulse

Use of the TIM peripheral to generate a single pulse when an external signal rising edge is received on the timer input pin. - X - - - X X -

TIM_PWMInput

How to use the TIM peripheral to measure the frequency and duty cycle of an external signal. - CubeMx - - - CubeMx CubeMx CubeMx

TIM_PWMOutput

This example shows how to configure the TIM peripheral in PWM (Pulse Width Modulation) mode. CubeMx CubeMx - - CubeMx CubeMx CubeMx CubeMx

TIM_TimeBase

Configuration of the TIM peripheral to generate a time base of one second with the corresponding interrupt request. - CubeMx - CubeMx - CubeMx CubeMx CubeMx

UART

LPUART_WakeUpFromStop

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

UART_HyperTerminal_DMA

UART transmission (transmit/receive) in DMA mode between a board and an HyperTerminal PC application. - CubeMx - - - - - -

UART_Printf

Re-routing of the C library printf function to the UART. CubeMx 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 - - CubeMx CubeMx CubeMx CubeMx

UART_TwoBoards_ComIT

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

UART_TwoBoards_ComPolling

UART transmission (transmit/receive) in Polling mode between two boards. - CubeMx - - - CubeMx 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 CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx CubeMx
Total number of examples: 357 48 81 17 14 34 70 58 35

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

ADC_ContinuousConversion_TriggerSW

How to use an ADC peripheral to perform continuous ADC conversions on a channel, from a software start. - - - - - X X -

ADC_ContinuousConversion_TriggerSW_Init

How to use an ADC peripheral to perform continuous ADC conversions on a channel, from a software start. - - - - CubeMx CubeMx CubeMx -

ADC_ContinuousConversion_TriggerSW_LowPower_Init

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

ADC_MultiChannelSingleConversion

How to use an ADC peripheral to convert several channels. ADC conversions are performed successively in a scan sequence. - - - - - X - -

ADC_Oversampling_Init

How to use an ADC peripheral with ADC oversampling. - - - - - CubeMx 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 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 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 CubeMx 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 CubeMx -

COMP

COMP_CompareGpioVsVrefInt_IT

How to use a comparator peripheral to compare a voltage level applied on a GPIO pin to the internal voltage reference (VREFINT), in interrupt mode. This example is based on the STM32G0xx COMP LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X - -

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 STM32G0xx COMP LL API. The peripheral initialization uses the LL initialization function to demonstrate LL init usage. - - - - CubeMx 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 STM32G0xx 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 STM32G0xx 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 CubeMx 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 CubeMx CubeMx 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 CubeMx CubeMx

CRS

CRS_Synchronization_IT

How to configure the clock recovery service in IT mode through the STM32G0xx CRS LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - CubeMx - - -

CRS_Synchronization_Polling

How to configure the clock recovery service in polling mode through the STM32G0xx CRS LL API. The peripheral initialization uses 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 STM32G0xx 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 STM32G0xx DAC LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - CubeMx CubeMx - -

DAC_GenerateWaveform_TriggerHW

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

DMA

DMA_CopyFromFlashToMemory

How to use a DMA channel to transfer a word data buffer from Flash memory to embedded SRAM. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X X -

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

EXTI

EXTI_ToggleLedOnIT

How to configure the EXTI and use GPIOs to toggle the user LEDs available on the board when a user button is pressed. It is based on the STM32G0xx LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X X -

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 STM32G0xx LL API. Peripheral initialization is done using LL initialization function to demonstrate LL init usage. - - - - - CubeMx CubeMx CubeMx

GPIO

GPIO_InfiniteLedToggling

How to configure and use GPIOs to toggle the on-board user LEDs every 250 ms. This example is based on the STM32G0xx LL API. The peripheral is initialized with LL unitary service functions to optimize for performance and size. - - - - - X X -

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

I2C

I2C_OneBoard_Communication_IT

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

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 - - 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 CubeMx 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_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. - - - - - CubeMx CubeMx 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 is pressed. The peripheral is initialized with LL unitary service functions to optimize for performance and size. - - - - CubeMx CubeMx CubeMx -

LPTIM

LPTIM_PulseCounter

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 STM32G0xx LPTIM LL API. The peripheral is initialized with LL unitary service functions to optimize for performance and size. - - - - - X - -

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

LPUART

LPUART_WakeUpFromStop

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 unitary service functions for optimization purposes (performance and size). - - - - - X - -

LPUART_WakeUpFromStop_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 - - - CubeMx - - 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 CubeMx CubeMx CubeMx

PWR_EnterStopMode

How to enter the STOP 0 mode. - - - - CubeMx CubeMx CubeMx CubeMx

RCC

RCC_OutputSystemClockOnMCO

Configuration of MCO pin (PA8) to output the system clock. - - - - CubeMx CubeMx CubeMx -

RCC_UseHSI_PLLasSystemClock

Modification of the PLL parameters in run time. - - - - CubeMx CubeMx CubeMx CubeMx

RTC

RTC_Alarm

Configuration of the RTC LL API to configure and generate an alarm using the RTC peripheral. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X X -

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

RTC_ExitStandbyWithWakeUpTimer_Init

Configuration of the RTC to wake up from Standby mode using the RTC Wakeup timer. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - CubeMx 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 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 CubeMx -

SPI

SPI_OneBoard_HalfDuplex_IT

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

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

SPI_TwoBoards_FullDuplex_IT_Master_Init

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

SPI_TwoBoards_FullDuplex_IT_Slave_Init

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

TIM

TIM_BreakAndDeadtime

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

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

TIM_PWMOutput

Use of a timer peripheral to generate a PWM output signal and update the PWM duty cycle. This example is based on the STM32G0xx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X - -

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 STM32G0xx TIM LL API. The peripheral initialization uses LL initialization function to demonstrate LL Init. - - - - - CubeMx CubeMx -

TIM_TimeBase

Configuration of the TIM peripheral to generate a timebase. This example is based on the STM32G0xx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - - X -

TIM_TimeBase_Init

Configuration of the TIM peripheral to generate a timebase. This example is based on the STM32G0xx TIM LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - CubeMx CubeMx CubeMx

USART

USART_Communication_Rx_IT

Configuration of GPIO and USART peripherals to receive characters from an HyperTerminal (PC) in Asynchronous mode using an interrupt. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X X -

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

USART_Communication_TxRx_DMA

Configuration of GPIO and USART peripherals to send characters asynchronously to/from an HyperTerminal (PC) in DMA mode. - - - - - X - -

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

USART_Communication_Tx_IT

Configuration of GPIO and USART peripherals to send characters asynchronously to HyperTerminal (PC) in Interrupt mode. This example is based on the STM32G0xx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - X - -

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 STM32G0xx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). - - - - - CubeMx 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 STM32G0xx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). - - - - - CubeMx 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 STM32G0xx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). - - - - - CubeMx 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 STM32G0xx USART LL API. Peripheral initialization is done using LL unitary services functions for optimization purpose (performance and size). - - - - - CubeMx 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 STM32G0xx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - CubeMx 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 STM32G0xx USART LL API. The peripheral initialization uses LL unitary service functions for optimization purposes (performance and size). - - - - - CubeMx 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 STM32G0xx 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 CubeMx -

USART_WakeUpFromStop

Configuration of GPIO and USART1 peripherals to allow the characters received on USART_RX pin to wake up MCU from low power mode. This example is based on the STM32G0xx USART1 LL API. - - - - - X - -

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

UTILS

UTILS_ConfigureSystemClock

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

UTILS_ReadDeviceInfo

This example reads the UID, Device ID and Revision ID and saves them into a global information buffer. - - - - CubeMx CubeMx CubeMx 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 CubeMx CubeMx -
Total number of examples_ll: 183 2 0 1 0 24 74 59 23

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 STM32G0xx ADC HAL and LL API. The LL API is used for performance improvement. - - - - CubeMx CubeMx CubeMx CubeMx

CRC

CRC_PolynomialUpdate

How to use the CRC peripheral through the STM32G0xx CRC HAL and LL API. - - CubeMx - CubeMx CubeMx CubeMx CubeMx

DMA

DMA_FLASHToRAM

How to use a DMA to transfer a word data buffer from Flash memory to embedded SRAM through the STM32G0xx DMA HAL and LL API. The LL API is used for performance improvement. - - CubeMx - CubeMx CubeMx CubeMx 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 STM32G0xx I2C HAL and LL API (LL API usage for performance improvement) and an interrupt. - - - - CubeMx CubeMx CubeMx 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 CubeMx CubeMx CubeMx

SPI_FullDuplex_ComPolling_Slave

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

TIM

TIM_PWMInput

Use of the TIM peripheral to measure an external signal frequency and duty cycle. - - - - CubeMx CubeMx 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 STM32G0xx UART HAL and LL API, the LL API being used for performance improvement. - - - - - CubeMx 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 STM32G0xx UART HAL and LL API, the LL API being used for performance improvement. - - - - CubeMx CubeMx CubeMx -
Total number of examples_mix: 35 0 0 2 0 9 9 9 6

Applications

-

OpenBootloader

This application exploits OpenBootloader Middleware to demonstrate how to develop an IAP application and how use it. X - - - - - - -

FatFs

FatFs_MultiAccess_RTOS

How to use STM32Cube firmware with FatFs middleware component as a generic FAT file system module, FreeRTOS as an RTOS module based on using CMSIS-OS-V2 wrapping layer common APIs. X - - - - - - -

FatFs_uSD_DMA_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. X - - - - - - -

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

FreeRTOS

FreeRTOS_Mail

How to use mail queues with CMSIS RTOS API. - CubeMx - CubeMx - CubeMx CubeMx CubeMx

FreeRTOS_Mutexes

How to use mutexes with CMSIS RTOS API. - CubeMx - - - CubeMx CubeMx -

FreeRTOS_Queues

How to use message queues with CMSIS RTOS API. - CubeMx - CubeMx CubeMx CubeMx CubeMx CubeMx

FreeRTOS_Semaphore

How to use semaphores with CMSIS RTOS API. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

FreeRTOS_SemaphoreFromISR

How to use semaphore from ISR with CMSIS RTOS API. - CubeMx - - - CubeMx CubeMx -

FreeRTOS_Signal

How to perform thread signaling using CMSIS RTOS API. - CubeMx - - - CubeMx CubeMx -

FreeRTOS_SignalFromISR

This application shows the usage of CMSIS-OS Signal API from ISR context. - CubeMx - - - CubeMx CubeMx -

FreeRTOS_ThreadCreation

How to implement thread creation using CMSIS RTOS API. - CubeMx - - - CubeMx CubeMx -

FreeRTOS_Timers

How to use timers of CMSIS RTOS API. CubeMx CubeMx - - CubeMx CubeMx CubeMx -

USB-PD

USB-PD_Consumer_1port

How to create a simple type C Consumer. CubeMx CubeMx - - - - - -

USB-PD_Provider_1port

How to create a simple type C provider. CubeMx CubeMx - - - - - -

USB_Device

CDC_Standalone

This application describes how to use USB device application based on the Device Communication Class (CDC) following the PSTN sub-protocol on the STM32G0C1E-EV devices. X - - - X - - -

DFU_Standalone

Compliant implementation of the Device Firmware Upgrade (DFU) capability to program the embedded Flash memory through the USB peripheral. X - - - - - - -

HID_Standalone

Use of the USB device application based on the Human Interface (HID). X - - - - - - -

MSC_Standalone

This application shows how to use the USB device application based on the Mass Storage Class (MSC) on the STM32G0xx devices. X - - - - - - -

USB_Host

HID_Standalone

This application is a part of the USB Host Library package using STM32Cube firmware. It describes how to use USB host application based on the Human Interface Class (HID) on the STM32G0XX devices. X - - - - - - -

MSC_Standalone

This application is a part of the USB Host Library package using STM32Cube firmware. It describes how to use USB host application based on the Mass Storage Class (MSC) on the STM32G0XX devices. X - - - - - - -
Total number of applications: 53 13 12 0 2 4 10 10 2

Demonstrations

-

Adafruit_LCD_1_8_SD_Joystick

This demonstration firmware is based on STM32Cube. It helps you to discover STM32 Cortex-M devices that can be plugged on a STM32 Nucleo board. - - - - - CubeMx CubeMx -

Demo

This demonstration firmware provides a sub-set of applications supported by the STM32G0C1E-EV board(MB1581) equipped with either Legacy daughter board(MB1351) or USB-PD board(MB1352). X - - X - - - -

DemoLegacy

The provided demonstration "Legacy" firmware based on STM32Cube helps you to discover STM32 Cortex-M devices that can be plugged on a STM32G081B-EVAL board. - X - - - - - -

DemoLoader

The provided demonstration "Loader" firmware based on STM32Cube helps you to discover STM32 Cortex-M devices that can be plugged on a STM32G081B-EVAL board. - X - - - - - -

DemoUCPD

This demonstration firmware is based on STM32Cube and describes how to use USB Power Delivery (USB-PD) feature based on STM32G081B-EVAL + MB1352 extension boards. - X - - - - - -

Gravitech_4digits

Demonstration of firmware based on STM32Cube. This demonstration provides firmware to help you to discover STM32 Cortex-M devices that are plugged onto an your STM32NUCLEO_32 board. - - - - - - - X

USBPD_Analyzer

This demonstration firmware is based on STM32Cube and describes how to use USB Power Delivery (USB-PD) feature based on STM32G071B-DISCO boards. - - X - - - - -
Total number of demonstrations: 9 1 3 1 1 0 1 1 1
Total number of projects: 653 66 98 23 19 73 166 139 69