STM32F4xx HAL

https://github.com/xywml/stm32f4_hal_doc
Admin
STM32F4xx HAL provides standard, highly portable hardware abstraction layer drivers to simplify...
Tokens:11,114,941
Snippets:68,797
Trust Score:5.2
License:BSD-3-Clause
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### CRYP HAL Driver Usage Guide

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F417xx_User_Manual/stm32f4xx__hal__cryp_8c.html

This is a textual usage guide for the CRYP HAL driver, not a code example. It outlines the steps to initialize and use the driver, including enabling clocks, configuring interrupts and DMA, and setting parameters. It is included for completeness but contains no executable code.

```text
  ==============================================================================
                     ##### How to use this driver #####
  ==============================================================================
    [..]
      The CRYP HAL driver can be used in CRYP or TinyAES IP as follows:

      (#)Initialize the CRYP low level resources by implementing the HAL_CRYP_MspInit():
         (##) Enable the CRYP interface clock using __HAL_RCC_CRYP_CLK_ENABLE()or
              __HAL_RCC_AES_CLK_ENABLE for TinyAES IP
         (##) In case of using interrupts (e.g. HAL_CRYP_Encrypt_IT())
             (+++) Configure the CRYP interrupt priority using HAL_NVIC_SetPriority()
             (+++) Enable the CRYP IRQ handler using HAL_NVIC_EnableIRQ()
             (+++) In CRYP IRQ handler, call HAL_CRYP_IRQHandler()
         (##) In case of using DMA to control data transfer (e.g. HAL_CRYP_Encrypt_DMA())
             (+++) Enable the DMAx interface clock using __RCC_DMAx_CLK_ENABLE()
             (+++) Configure and enable two DMA streams one for managing data transfer from
                 memory to peripheral (input stream) and another stream for managing data
                 transfer from peripheral to memory (output stream)
             (+++) Associate the initialized DMA handle to the CRYP DMA handle
                 using  __HAL_LINKDMA()
             (+++) Configure the priority and enable the NVIC for the transfer complete
                 interrupt on the two DMA Streams. The output stream should have higher
                 priority than the input stream HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ()

      (#)Initialize the CRYP according to the specified parameters :
         (##) The data type: 1-bit, 8-bit, 16-bit or 32-bit.
         (##) The key size: 128, 192 or 256.
         (##) The AlgoMode DES/ TDES Algorithm ECB/CBC or AES Algorithm ECB/CBC/CTR/GCM or CCM.
         (##) The initialization vector (counter). It is not used in ECB mode.
         (##) The key buffer used for encryption/decryption.
         (##) The Header used only in AES GCM and CCM Algorithm for authentication.
         (##) The HeaderSize The size of header buffer in word.
         (##) The B0 block is the first authentication block used only  in AES CCM mode.

      (#)Three processing (encryption/decryption) functions are available:
         (##) Polling mode: encryption and decryption APIs are blocking functions
              i.e. they process the data and wait till the processing is finished,
              e.g. HAL_CRYP_Encrypt & HAL_CRYP_Decrypt
         (##) Interrupt mode: encryption and decryption APIs are not blocking functions
              i.e. they process the data under interrupt,
              e.g. HAL_CRYP_Encrypt_IT & HAL_CRYP_Decrypt_IT
         (##) DMA mode: encryption and decryption APIs are not blocking functions
              i.e. the data transfer is ensured by DMA,
              e.g. HAL_CRYP_Encrypt_DMA & HAL_CRYP_Decrypt_DMA

      (#)When the processing function is called at first time after HAL_CRYP_Init()
         the CRYP peripheral is configured and processes the buffer in input.
         At second call, no need to Initialize the CRYP, user have to get current configuration via
         HAL_CRYP_GetConfig() API, then only  HAL_CRYP_SetConfig() is requested to set
         new parameters, finally user can  start encryption/decryption.

       (#)Call HAL_CRYP_DeInit() to deinitialize the CRYP peripheral.

       (#)To process a single message with consecutive calls to HAL_CRYP_Encrypt() or HAL_CRYP_Decrypt()
          without having to configure again the Key or the Initialization Vector between each API call,
          the field KeyIVConfigSkip of the initialization structure must be set to CRYP_KEYIVCONFIG_ONCE.
          Same is true for consecutive calls of HAL_CRYP_Encrypt_IT(), HAL_CRYP_Decrypt_IT(), HAL_CRYP_Encrypt_DMA()
          or HAL_CRYP_Decrypt_DMA().
```

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

### ETH HAL driver usage steps

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__eth_8c.html

Usage guide for the STM32F4xx ETH HAL driver. Steps cover declaring a ETH_HandleTypeDef, initializing via HAL_ETH_Init() and HAL_ETH_MspInit(), starting reception with HAL_ETH_Start() or HAL_ETH_Start_IT(), reading data with HAL_ETH_ReadData(), transmitting with HAL_ETH_Transmit() or HAL_ETH_Transmit_IT(), and configuring MAC/DMA via HAL_ETH_GetMACConfig()/HAL_ETH_SetMACConfig() and HAL_ETH_GetDMAConfig()/HAL_ETH_SetDMAConfig().

```c
  ==============================================================================
                    ##### How to use this driver #####
  ==============================================================================
     [..]
     The ETH HAL driver can be used as follows:

      (#)Declare a ETH_HandleTypeDef handle structure, for example:
         ETH_HandleTypeDef  heth;

      (#)Fill parameters of Init structure in heth handle

      (#)Call HAL_ETH_Init() API to initialize the Ethernet peripheral (MAC, DMA, ...)

      (#)Initialize the ETH low level resources through the HAL_ETH_MspInit() API:
          (##) Enable the Ethernet interface clock using
                (+++)  __HAL_RCC_ETH1MAC_CLK_ENABLE()
                (+++)  __HAL_RCC_ETH1TX_CLK_ENABLE()
                (+++)  __HAL_RCC_ETH1RX_CLK_ENABLE()

          (##) Initialize the related GPIO clocks
          (##) Configure Ethernet pinout
          (##) Configure Ethernet NVIC interrupt (in Interrupt mode)

      (#) Ethernet data reception is asynchronous, so call the following API
          to start the listening mode:
          (##) HAL_ETH_Start():
               This API starts the MAC and DMA transmission and reception process,
               without enabling end of transfer interrupts, in this mode user
               has to poll for data reception by calling HAL_ETH_ReadData()
          (##) HAL_ETH_Start_IT():
               This API starts the MAC and DMA transmission and reception process,
               end of transfer interrupts are enabled in this mode,
               HAL_ETH_RxCpltCallback() will be executed when an Ethernet packet is received

      (#) When data is received user can call the following API to get received data:
          (##) HAL_ETH_ReadData(): Read a received packet

      (#) For transmission path, two APIs are available:
         (##) HAL_ETH_Transmit(): Transmit an ETH frame in blocking mode
         (##) HAL_ETH_Transmit_IT(): Transmit an ETH frame in interrupt mode,
              HAL_ETH_TxCpltCallback() will be executed when end of transfer occur

      (#) Communication with an external PHY device:
         (##) HAL_ETH_ReadPHYRegister(): Read a register from an external PHY
         (##) HAL_ETH_WritePHYRegister(): Write data to an external RHY register

      (#) Configure the Ethernet MAC after ETH peripheral initialization
          (##) HAL_ETH_GetMACConfig(): Get MAC actual configuration into ETH_MACConfigTypeDef
          (##) HAL_ETH_SetMACConfig(): Set MAC configuration based on ETH_MACConfigTypeDef

      (#) Configure the Ethernet DMA after ETH peripheral initialization
          (##) HAL_ETH_GetDMAConfig(): Get DMA actual configuration into ETH_DMAConfigTypeDef
          (##) HAL_ETH_SetDMAConfig(): Set DMA configuration based on ETH_DMAConfigTypeDef
```

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

### HAL_CAN_Start()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_0x68.html

Starts the CAN peripheral.

```APIDOC
## HAL_CAN_Start

### Description
Starts the CAN peripheral, enabling message transmission and reception.

### Parameters
- **hcan** (CAN_HandleTypeDef*) - Pointer to the CAN handle.

### Returns
- **HAL_StatusTypeDef** - HAL status.
```

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

### HAL_ETH_Start()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_0x68.html

Starts the Ethernet transmission and reception.

```APIDOC
## HAL_ETH_Start()

### Description
Starts the Ethernet transmission and reception.

### Method
Function

### Endpoint
HAL_ETH_Start()

### Parameters
- **heth** (ETH_HandleTypeDef*) - Pointer to ETH handle

### Returns
HAL_StatusTypeDef
```

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

### HAL_HASH_MD5_Start

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_func_0x68.html

Starts MD5 computation.

```APIDOC
## HAL_HASH_MD5_Start

### Description
Starts the MD5 hash computation on the given input data.

### Function Signature
`HAL_StatusTypeDef HAL_HASH_MD5_Start(HASH_HandleTypeDef *hhash, uint8_t *pInBuffer, uint32_t Size, uint8_t *pOutBuffer)`

### Parameters
- **hhash** (HASH_HandleTypeDef*) - Pointer to the HASH handle.
- **pInBuffer** (uint8_t*) - Pointer to the input data buffer.
- **Size** (uint32_t) - Size of the input data in bytes.
- **pOutBuffer** (uint8_t*) - Pointer to the output buffer for the digest.

### Return Value
- **HAL_StatusTypeDef** - HAL_OK on success, HAL_ERROR on failure.

### Notes
- This function performs the complete MD5 computation.

```

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

### HASH_Start()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F479xx_User_Manual/globals_func_0x68.html

Starts the hashing process.

```APIDOC
## HASH_Start

### Description
Starts the hashing process.

### Parameters
- **hhash** (HASH_HandleTypeDef*) - Pointer to a HASH_HandleTypeDef structure that contains the configuration information for the specified HASH module.
- **pData** (uint8_t*) - Pointer to data buffer
- **Size** (uint32_t) - Size of data

### Returns
- **HAL_StatusTypeDef** - HAL status
```

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

### LL_DMA2D_Start()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_0x6c.html

Starts the DMA2D controller operation.

```APIDOC
## LL_DMA2D_Start()

### Description
Starts the DMA2D controller operation.

### Method
Function

### Signature
`void LL_DMA2D_Start(DMA2D_TypeDef *DMA2Dx)`

### Parameters
- **DMA2Dx** (DMA2D_TypeDef*) - Pointer to the DMA2D peripheral register base.

### Returns
None

### Notes
This function is defined in stm32f4xx_ll_dma2d.h.
```

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

### HAL_HCD_Start()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F423xx_User_Manual/globals_func_0x68.html

Starts the HCD operation.

```APIDOC
## HAL_HCD_Start()

### Description
Starts the HCD operation.

### Method
N/A (C function)

### Endpoint
N/A

### Parameters
None documented.

### Request Example
N/A

### Response
N/A
```

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

### LL_I2C_GenerateStartCondition()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_func_0x6c.html

Generates a start condition.

```APIDOC
## LL_I2C_GenerateStartCondition()

### Description
Generates a start condition.

### Function
LL_I2C_GenerateStartCondition()

### Parameters
None.

### Return Value
None.
```

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

### HAL_HMAC_MD5_Start

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_func_0x68.html

Starts HMAC-MD5 computation.

```APIDOC
## HAL_HMAC_MD5_Start

### Description
Starts HMAC-MD5 computation.

### Method
N/A

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### How to use this driver - Initialization steps

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__qspi_8c.html

Usage instructions for the QSPI HAL driver. Lists the prerequisite steps for HAL_QSPI_MspInit() including enabling clocks, resetting the peripheral, configuring GPIOs, and setting up interrupts or DMA. Then instructs to configure flash size, clock prescaler, FIFO threshold, clock mode, sample shifting, and CS high time with HAL_QSPI_Init().

```text
 ===============================================================================
                        ##### How to use this driver #####
 ===============================================================================
  [..]
    *** Initialization ***
    ======================
    [..]
      (#) As prerequisite, fill in the HAL_QSPI_MspInit() :
        (++) Enable QuadSPI clock interface with __HAL_RCC_QSPI_CLK_ENABLE().
        (++) Reset QuadSPI Peripheral with __HAL_RCC_QSPI_FORCE_RESET() and __HAL_RCC_QSPI_RELEASE_RESET().
        (++) Enable the clocks for the QuadSPI GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE().
        (++) Configure these QuadSPI pins in alternate mode using HAL_GPIO_Init().
        (++) If interrupt mode is used, enable and configure QuadSPI global
            interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
        (++) If DMA mode is used, enable the clocks for the QuadSPI DMA channel
            with __HAL_RCC_DMAx_CLK_ENABLE(), configure DMA with HAL_DMA_Init(),
            link it with QuadSPI handle using __HAL_LINKDMA(), enable and configure
            DMA channel global interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
      (#) Configure the flash size, the clock prescaler, the fifo threshold, the
          clock mode, the sample shifting and the CS high time using the HAL_QSPI_Init() function.
```

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

### PCD HAL Driver Header and Usage Guide

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__pcd_8c_source.html

Header and usage guide for the STM32F4xx PCD HAL driver. It lists the steps to initialize and use the driver: declare a PCD_HandleTypeDef, fill init parameters, call HAL_PCD_Init(), configure MSP via HAL_PCD_MspInit(), associate the upper USB stack with hpcd.pData, and start with HAL_PCD_Start(). Includes examples of clock enable macros __HAL_RCC_USB_OTG_FS_CLK_ENABLE() and __HAL_RCC_USB_OTG_HS_CLK_ENABLE().

```c
/**
  ******************************************************************************
  * @file    stm32f4xx_hal_pcd.c
  * @author  MCD Application Team
  * @brief   PCD HAL module driver.
  *          This file provides firmware functions to manage the following
  *          functionalities of the USB Peripheral Controller:
  *           + Initialization and de-initialization functions
  *           + IO operation functions
  *           + Peripheral Control functions
  *           + Peripheral State functions
  *
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2016 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  @verbatim
  ==============================================================================
                    ##### How to use this driver #####
  ==============================================================================
    [..]
      The PCD HAL driver can be used as follows:

     (#) Declare a PCD_HandleTypeDef handle structure, for example:
         PCD_HandleTypeDef  hpcd;

     (#) Fill parameters of Init structure in HCD handle

     (#) Call HAL_PCD_Init() API to initialize the PCD peripheral (Core, Device core, ...)

     (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
         (##) Enable the PCD/USB Low Level interface clock using
              (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
              (+++) __HAL_RCC_USB_OTG_HS_CLK_ENABLE(); (For High Speed Mode)

         (##) Initialize the related GPIO clocks
         (##) Configure PCD pin-out
         (##) Configure PCD NVIC interrupt

     (#)Associate the Upper USB device stack to the HAL PCD Driver:
         (##) hpcd.pData = pdev;

     (#)Enable PCD transmission and reception:
         (##) HAL_PCD_Start();

  @endverbatim
  ******************************************************************************
  */
```

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

### __HAL_CEC_GET_TRANSMISSION_START_FLAG

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__cec_8h_source.html

Gets the Transmission Start flag.

```APIDOC
## __HAL_CEC_GET_TRANSMISSION_START_FLAG

### Description
Gets the Transmission Start flag.

### Parameters
- **__HANDLE__** (CEC_HandleTypeDef*) - Required - CEC Handle.

### Return Value
FlagStatus - Status of the transmission start flag.
```

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

### QSPI Initialization and Configuration Functions Overview

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F412Zx_User_Manual/stm32f4xx__hal__qspi_8c_source.html

Documentation block describing the initialization and configuration functions group.

```c
@verbatim
===============================================================================
            ##### Initialization and Configuration functions #####
 ===============================================================================
    [..]
    This subsection provides a set of functions allowing to :
      (+) Initialize the QuadSPI.
      (+) De-initialize the QuadSPI.

@endverbatim
```

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

### HAL_DFSDM_ChannelScdStart

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F423xx_User_Manual/globals_func_0x68.html

Starts DFSDM channel SCD.

```APIDOC
## HAL_DFSDM_ChannelScdStart

### Description
Starts DFSDM channel SCD.

### Source File
stm32f4xx_hal_dfsdm.c

### Group
DFSDM Exported Functions Group2 Channel

### Parameters
None documented.

### Returns
None documented.
```

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

### DMA Burst Setup for TIM_DMA_COM Request

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__tim_8c_source.html

Configures DMA callbacks for commutation event and starts DMA transfer. Returns HAL_ERROR if DMA start fails.

```c
    case TIM_DMA_COM:
    {
      /* Set the DMA commutation callbacks */
      htim->hdma[TIM_DMA_ID_COMMUTATION]->XferCpltCallback =  TIMEx_DMACommutationCplt;
      htim->hdma[TIM_DMA_ID_COMMUTATION]->XferHalfCpltCallback =  TIMEx_DMACommutationHalfCplt;

      /* Set the DMA error callback */
      htim->hdma[TIM_DMA_ID_COMMUTATION]->XferErrorCallback = TIM_DMAError ;
```

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

### HAL_SD_MspInit()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F423xx_User_Manual/globals_func_0x68.html

Initializes the SD MSP.

```APIDOC
## HAL_SD_MspInit

### Description
Initializes the SD MSP.

### Method
HAL_SD_MspInit

### Parameters
- **hsd** (SD_HandleTypeDef*) - Pointer to an SD_HandleTypeDef structure.

### Returns
void
```

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

### HAL_QSPI_Init

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__qspi_8h_source.html

Initializes the QSPI peripheral.

```APIDOC
## HAL_QSPI_Init

### Description
Initializes the QSPI peripheral according to the specified parameters in the QSPI_InitTypeDef and initializes the associated handle.

### Method
Function

### Signature
HAL_StatusTypeDef HAL_QSPI_Init(QSPI_HandleTypeDef *hqspi)

### Parameters
- **hqspi** (QSPI_HandleTypeDef*) - Pointer to a QSPI_HandleTypeDef structure that contains the configuration information for the QSPI module.

### Return Value
- **HAL_StatusTypeDef** - HAL status (HAL_OK, HAL_ERROR, HAL_BUSY, HAL_TIMEOUT).

```

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

### __HAL_CEC_GET_TRANSMISSION_START_FLAG

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__cec_8h_source.html

Gets the Transmission Start flag (TXSOM) status from the CR register.

```APIDOC
## __HAL_CEC_GET_TRANSMISSION_START_FLAG

### Description
Gets the Transmission Start flag (TXSOM) status from the CR register.

### Parameters
- **__HANDLE__** (CEC_HandleTypeDef*) - Required - The CEC handle.

### Return Value
FlagStatus - The status of the TXSOM bit (SET or RESET).
```

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

### HAL_DFSDM_ChannelCkabStart

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F423xx_User_Manual/globals_func_0x68.html

Starts DFSDM channel CKAB.

```APIDOC
## HAL_DFSDM_ChannelCkabStart

### Description
Starts DFSDM channel CKAB.

### Source File
stm32f4xx_hal_dfsdm.c

### Group
DFSDM Exported Functions Group2 Channel

### Parameters
None documented.

### Returns
None documented.
```

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

### DMA Burst Setup for TIM_DMA_CC2 Request

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__tim_8c_source.html

Configures DMA callbacks for capture/compare channel 2 and starts DMA transfer. Returns HAL_ERROR if DMA start fails.

```c
    case TIM_DMA_CC2:
    {
      /* Set the DMA compare callbacks */
      htim->hdma[TIM_DMA_ID_CC2]->XferCpltCallback = TIM_DMADelayPulseCplt;
      htim->hdma[TIM_DMA_ID_CC2]->XferHalfCpltCallback = TIM_DMADelayPulseHalfCplt;

      /* Set the DMA error callback */
      htim->hdma[TIM_DMA_ID_CC2]->XferErrorCallback = TIM_DMAError ;

      /* Enable the DMA stream */
      if (HAL_DMA_Start_IT(htim->hdma[TIM_DMA_ID_CC2], (uint32_t)BurstBuffer,
                           (uint32_t)&htim->Instance->DMAR, DataLength) != HAL_OK)
      {
        /* Return error status */
        return HAL_ERROR;
      }
      break;
    }
```

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

### How to use this driver - Initialization and functional modes

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F412Zx_User_Manual/stm32f4xx__hal__qspi_8c.html

This block is the main usage guide for the QSPI HAL driver. It lists the prerequisites for HAL_QSPI_MspInit(), including enabling clocks, resetting the peripheral, configuring GPIOs, and setting up interrupts or DMA. It then describes the steps for configuring the flash via HAL_QSPI_Init() and explains the indirect functional mode, covering command configuration with HAL_QSPI_Command() or HAL_QSPI_Command_IT(), and the transmit/receive functions in polling, interrupt, and DMA modes with their respective callbacks.

```c
 ===============================================================================
                        ##### How to use this driver #####
 ===============================================================================
  [..]
    *** Initialization ***
    ======================
    [..]
      (#) As prerequisite, fill in the HAL_QSPI_MspInit() :
        (++) Enable QuadSPI clock interface with __HAL_RCC_QSPI_CLK_ENABLE().
        (++) Reset QuadSPI Peripheral with __HAL_RCC_QSPI_FORCE_RESET() and __HAL_RCC_QSPI_RELEASE_RESET().
        (++) Enable the clocks for the QuadSPI GPIOS with __HAL_RCC_GPIOx_CLK_ENABLE().
        (++) Configure these QuadSPI pins in alternate mode using HAL_GPIO_Init().
        (++) If interrupt mode is used, enable and configure QuadSPI global
            interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
        (++) If DMA mode is used, enable the clocks for the QuadSPI DMA channel
            with __HAL_RCC_DMAx_CLK_ENABLE(), configure DMA with HAL_DMA_Init(),
            link it with QuadSPI handle using __HAL_LINKDMA(), enable and configure
            DMA channel global interrupt with HAL_NVIC_SetPriority() and HAL_NVIC_EnableIRQ().
      (#) Configure the flash size, the clock prescaler, the fifo threshold, the
          clock mode, the sample shifting and the CS high time using the HAL_QSPI_Init() function.

    *** Indirect functional mode ***
    ================================
    [..]
      (#) Configure the command sequence using the HAL_QSPI_Command() or HAL_QSPI_Command_IT()
          functions :
         (++) Instruction phase : the mode used and if present the instruction opcode.
         (++) Address phase : the mode used and if present the size and the address value.
         (++) Alternate-bytes phase : the mode used and if present the size and the alternate
             bytes values.
         (++) Dummy-cycles phase : the number of dummy cycles (mode used is same as data phase).
         (++) Data phase : the mode used and if present the number of bytes.
         (++) Double Data Rate (DDR) mode : the activation (or not) of this mode and the delay
             if activated.
         (++) Sending Instruction Only Once (SIOO) mode : the activation (or not) of this mode.
      (#) If no data is required for the command, it is sent directly to the memory :
         (++) In polling mode, the output of the function is done when the transfer is complete.
         (++) In interrupt mode, HAL_QSPI_CmdCpltCallback() will be called when the transfer is complete.
      (#) For the indirect write mode, use HAL_QSPI_Transmit(), HAL_QSPI_Transmit_DMA() or
          HAL_QSPI_Transmit_IT() after the command configuration :
         (++) In polling mode, the output of the function is done when the transfer is complete.
         (++) In interrupt mode, HAL_QSPI_FifoThresholdCallback() will be called when the fifo threshold
             is reached and HAL_QSPI_TxCpltCallback() will be called when the transfer is complete.
         (++) In DMA mode, HAL_QSPI_TxHalfCpltCallback() will be called at the half transfer and
             HAL_QSPI_TxCpltCallback() will be called when the transfer is complete.
      (#) For the indirect read mode, use HAL_QSPI_Receive(), HAL_QSPI_Receive_DMA() or
          HAL_QSPI_Receive_IT() after the command configuration :
         (++) In polling mode, the output of the function is done when the transfer is complete.
         (++) In interrupt mode, HAL_QSPI_FifoThresholdCallback() will be called when the fifo threshold
             is reached and HAL_QSPI_RxCpltCallback() will be called when the transfer is complete.
         (++) In DMA mode, HAL_QSPI_RxHalfCpltCallback() will be called at the half transfer and
             HAL_QSPI_RxCpltCallback() will be called when the transfer is complete.
```

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

### DMA Burst Setup for TIM_DMA_CC1 Request

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__tim_8c_source.html

Configures DMA callbacks for capture/compare channel 1 and starts DMA transfer. Returns HAL_ERROR if DMA start fails.

```c
    case TIM_DMA_CC1:
    {
      /* Set the DMA compare callbacks */
      htim->hdma[TIM_DMA_ID_CC1]->XferCpltCallback = TIM_DMADelayPulseCplt;
      htim->hdma[TIM_DMA_ID_CC1]->XferHalfCpltCallback = TIM_DMADelayPulseHalfCplt;

      /* Set the DMA error callback */
      htim->hdma[TIM_DMA_ID_CC1]->XferErrorCallback = TIM_DMAError ;

      /* Enable the DMA stream */
      if (HAL_DMA_Start_IT(htim->hdma[TIM_DMA_ID_CC1], (uint32_t)BurstBuffer,
                           (uint32_t)&htim->Instance->DMAR, DataLength) != HAL_OK)
      {
        /* Return error status */
        return HAL_ERROR;
      }
      break;
    }
```

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

### FMPI2C HAL driver usage guide

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__hal__fmpi2c_8c.html

This comment block provides a step-by-step guide on how to use the FMPI2C HAL driver. It covers declaring the handle, initializing low-level resources via HAL_FMPI2C_MspInit(), configuring the Init structure, calling HAL_FMPI2C_Init(), checking device readiness with HAL_FMPI2C_IsDeviceReady(), and lists the available polling mode IO and IO MEM operations.

```c
  ==============================================================================
                        ##### How to use this driver #####
  ==============================================================================
    [..]
    The FMPI2C HAL driver can be used as follows:

    (#) Declare a FMPI2C_HandleTypeDef handle structure, for example:
        FMPI2C_HandleTypeDef  hfmpi2c;

    (#)Initialize the FMPI2C low level resources by implementing the HAL_FMPI2C_MspInit() API:
        (##) Enable the FMPI2Cx interface clock
        (##) FMPI2C pins configuration
            (+++) Enable the clock for the FMPI2C GPIOs
            (+++) Configure FMPI2C pins as alternate function open-drain
        (##) NVIC configuration if you need to use interrupt process
            (+++) Configure the FMPI2Cx interrupt priority
            (+++) Enable the NVIC FMPI2C IRQ Channel
        (##) DMA Configuration if you need to use DMA process
            (+++) Declare a DMA_HandleTypeDef handle structure for
                  the transmit or receive stream
            (+++) Enable the DMAx interface clock using
            (+++) Configure the DMA handle parameters
            (+++) Configure the DMA Tx or Rx stream
            (+++) Associate the initialized DMA handle to the hfmpi2c DMA Tx or Rx handle
            (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on
                  the DMA Tx or Rx stream

    (#) Configure the Communication Clock Timing, Own Address1, Master Addressing mode, Dual Addressing mode,
        Own Address2, Own Address2 Mask, General call and Nostretch mode in the hfmpi2c Init structure.

    (#) Initialize the FMPI2C registers by calling the HAL_FMPI2C_Init(), configures also the low level Hardware
        (GPIO, CLOCK, NVIC...etc) by calling the customized HAL_FMPI2C_MspInit(&hfmpi2c) API.

    (#) To check if target device is ready for communication, use the function HAL_FMPI2C_IsDeviceReady()

    (#) For FMPI2C IO and IO MEM operations, three operation modes are available within this driver :

    *** Polling mode IO operation ***
    =================================
    [..]
      (+) Transmit in master mode an amount of data in blocking mode using HAL_FMPI2C_Master_Transmit()
      (+) Receive in master mode an amount of data in blocking mode using HAL_FMPI2C_Master_Receive()
      (+) Transmit in slave mode an amount of data in blocking mode using HAL_FMPI2C_Slave_Transmit()
      (+) Receive in slave mode an amount of data in blocking mode using HAL_FMPI2C_Slave_Receive()

    *** Polling mode IO MEM operation ***
    =====================================
    [..]
      (+) Write an amount of data in blocking mode to a specific memory address using HAL_FMPI2C_Mem_Write()
      (+) Read an amount of data in blocking mode from a specific memory address using HAL_FMPI2C_Mem_Read()
```

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

### LL_ADC_INJ_IsTriggerSourceSWStart

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/group__ADC__LL__EF__Configuration__ADC__Group__Injected.html

Gets the ADC group injected conversion trigger source internal (SW start) or external.

```APIDOC
## LL_ADC_INJ_IsTriggerSourceSWStart

### Description
Gets the ADC group injected conversion trigger source internal (SW start) or external. In case of group injected trigger source set to external trigger, use LL_ADC_INJ_GetTriggerSource to determine which peripheral is selected as external trigger.

### Parameters
- **ADCx** (const ADC_TypeDef *) - Required - ADC instance

### Return Values
- "0" if trigger source is external trigger
- "1" if trigger source is SW start

### Reference Manual Cross Reference
- CR2 JEXTEN LL_ADC_INJ_IsTriggerSourceSWStart
```

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

### HAL_QSPI_MspInit

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__qspi_8h_source.html

Initializes the QSPI MSP.

```APIDOC
## HAL_QSPI_MspInit

### Description
Initializes the QSPI MSP (MCU Support Package).

### Method
Function

### Signature
void HAL_QSPI_MspInit(QSPI_HandleTypeDef *hqspi)

### Parameters
- **hqspi** (QSPI_HandleTypeDef*) - Pointer to a QSPI_HandleTypeDef structure.

### Return Value
None

```

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

### LL_ADC_REG_IsTriggerSourceSWStart

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/group__ADC__LL__EF__Configuration__ADC__Group__Regular.html

Get ADC group regular conversion trigger source internal (SW start) or external.

```APIDOC
## LL_ADC_REG_IsTriggerSourceSWStart

### Description
Get ADC group regular conversion trigger source internal (SW start) or external.

### Function Signature
```c
__STATIC_INLINE uint32_t LL_ADC_REG_IsTriggerSourceSWStart(const ADC_TypeDef *ADCx)
```

### Parameters
- **ADCx** (const ADC_TypeDef*) - Pointer to the ADC peripheral instance.

### Return Value
uint32_t - Value indicating if trigger source is SW start (1) or external (0).
```

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

### HAL_LIN_Init()

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F423xx_User_Manual/globals_func_0x68.html

Initializes the LIN peripheral.

```APIDOC
## HAL_LIN_Init()

### Description
Initializes the LIN peripheral.

### Method
N/A (C function)

### Endpoint
HAL_LIN_Init

### Parameters
- **huart** (UART_HandleTypeDef*) - Pointer to the UART handle.

### Request Example
N/A

### Response
#### Success Response (200)
- **HAL_StatusTypeDef** - HAL_OK on success, HAL_ERROR on failure.

#### Response Example
N/A
```

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

### LL_ADC_INJ_IsTriggerSourceSWStart

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/group__ADC__LL__EF__Configuration__ADC__Group__Injected.html

Get ADC group injected conversion trigger source internal (SW start) or external.

```APIDOC
## LL_ADC_INJ_IsTriggerSourceSWStart

### Description
Get ADC group injected conversion trigger source internal (SW start) or external.

### Method
Function

### Signature
`uint32_t LL_ADC_INJ_IsTriggerSourceSWStart(const ADC_TypeDef *ADCx)`

### Parameters
- **ADCx** (const ADC_TypeDef*) - Required - ADC instance

### Return Value
uint32_t - Indicates if trigger source is SW start (1) or external (0)

```

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

### How to Use the ADC Driver

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__adc_8c.html

Provides step-by-step instructions for initializing the ADC low-level resources, configuring ADC parameters, and executing conversions using polling, interruption, or DMA.

```text
  ==============================================================================
                    ##### How to use this driver #####
  ==============================================================================
  [..]
  (#)Initialize the ADC low level resources by implementing the HAL_ADC_MspInit():
       (##) Enable the ADC interface clock using __HAL_RCC_ADC_CLK_ENABLE()
       (##) ADC pins configuration
             (+++) Enable the clock for the ADC GPIOs using the following function:
                   __HAL_RCC_GPIOx_CLK_ENABLE()
             (+++) Configure these ADC pins in analog mode using HAL_GPIO_Init()
       (##) In case of using interrupts (e.g. HAL_ADC_Start_IT())
             (+++) Configure the ADC interrupt priority using HAL_NVIC_SetPriority()
             (+++) Enable the ADC IRQ handler using HAL_NVIC_EnableIRQ()
             (+++) In ADC IRQ handler, call HAL_ADC_IRQHandler()
       (##) In case of using DMA to control data transfer (e.g. HAL_ADC_Start_DMA())
             (+++) Enable the DMAx interface clock using __HAL_RCC_DMAx_CLK_ENABLE()
             (+++) Configure and enable two DMA streams stream for managing data
                 transfer from peripheral to memory (output stream)
             (+++) Associate the initialized DMA handle to the CRYP DMA handle
                 using  __HAL_LINKDMA()
             (+++) Configure the priority and enable the NVIC for the transfer complete
                 interrupt on the two DMA Streams. The output stream should have higher
                 priority than the input stream.
```

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

### Example: Using __LL_ADC_ANALOGWD_GET_THRESHOLD_RESOLUTION

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__ll__adc_8h_source.html

Example usage of the helper macro to get the analog watchdog threshold high value when ADC resolution is 8 bits. The macro __LL_ADC_ANALOGWD_GET_THRESHOLD_RESOLUTION is used with LL_ADC_GetAnalogWDThresholds() to retrieve the threshold value.

```c
LL_ADC_GetAnalogWDThresholds(<ADCx param>, LL_ADC_AWD_THRESHOLD_HIGH)
```

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

### HAL_PCCARD_MspInit

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F412Zx_User_Manual/stm32f4xx__hal__pccard_8c_source.html

Weak callback for low-level hardware initialization.

```APIDOC
## HAL_PCCARD_MspInit

### Description
Weak callback for low-level hardware initialization. Users can override this function to implement custom MSP initialization.

### Function Signature
```c
__weak void HAL_PCCARD_MspInit(PCCARD_HandleTypeDef *hpccard)
```

### Parameters
- **hpccard** (PCCARD_HandleTypeDef*) - Pointer to PCCARD handle structure.

### Return Value
- **void** - No return value.

### Description (Detailed)
This function is a weak callback that is called during HAL_PCCARD_Init. It should be overridden by the user to initialize the low-level hardware (e.g., GPIO, clocks).
```

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

### HAL_ETH_Init

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__eth_8h_source.html

Initializes the Ethernet peripheral.

```APIDOC
## HAL_ETH_Init

### Description
Initializes the Ethernet peripheral.

### Parameters
- **heth** (ETH_HandleTypeDef*) - Required - ETH Handle

### Returns
- HAL_StatusTypeDef: HAL status.

### Function Declaration
```c
HAL_StatusTypeDef HAL_ETH_Init(ETH_HandleTypeDef *heth);
```
```

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

### HAL_HASH_DMAFeed_IT - Input Parameter Validation and DMA Setup

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__hash_8c_source.html

Validates input parameters and phase coherency, then configures DMA for HASH processing. Handles both fresh start and resumption cases, setting up DMA callbacks and starting the transfer.

```c
  /* Check input parameters */
  if ((pInBuffer == NULL) || (Size == 0U) ||
      /* Check phase coherency. Phase must be
         either READY (fresh start)
         or PROCESS (multi-buffer HASH management) */
      ((hhash->Phase != HAL_HASH_PHASE_READY) && (!(IS_HASH_PROCESSING(hhash)))))
  {
    hhash->State = HAL_HASH_STATE_READY;
    return  HAL_ERROR;
  }


  /* Process Locked */
  __HAL_LOCK(hhash);

  /* If not a resumption case */
  if (hhash->State == HAL_HASH_STATE_READY)
  {
    /* Change the HASH state */
    hhash->State = HAL_HASH_STATE_BUSY;

    /* Check if initialization phase has already been performed.
       If Phase is already set to HAL_HASH_PHASE_PROCESS, this means the
       API is processing a new input data message in case of multi-buffer HASH
       computation. */
    if (hhash->Phase == HAL_HASH_PHASE_READY)
    {
      /* Select the HASH algorithm, clear HMAC mode and long key selection bit, reset the HASH processor core */
      MODIFY_REG(HASH->CR, HASH_CR_LKEY | HASH_CR_ALGO | HASH_CR_MODE | HASH_CR_INIT, Algorithm | HASH_CR_INIT);

      /* Set the phase */
      hhash->Phase = HAL_HASH_PHASE_PROCESS;
    }

    /* Configure the Number of valid bits in last word of the message */
    __HAL_HASH_SET_NBVALIDBITS(Size);

    inputaddr = (uint32_t)pInBuffer;     /* DMA transfer start address   */
    inputSize = Size;                    /* DMA transfer size (in bytes) */

    /* In case of suspension request, save the starting parameters */
    hhash->pHashInBuffPtr =  pInBuffer;  /* DMA transfer start address   */
    hhash->HashInCount = Size;           /* DMA transfer size (in bytes) */

  }
  /* If resumption case */
  else
  {
    /* Change the HASH state */
    hhash->State = HAL_HASH_STATE_BUSY;

    /* Resumption case, inputaddr and inputSize are not set to the API input parameters
       but to those saved beforehand by HAL_HASH_DMAFeed_ProcessSuspend() when the
       processing was suspended */
    inputaddr = (uint32_t)hhash->pHashInBuffPtr;  /* DMA transfer start address   */
    inputSize = hhash->HashInCount;               /* DMA transfer size (in bytes) */

  }

  /* Set the HASH DMA transfer complete callback */
  hhash->hdmain->XferCpltCallback = HASH_DMAXferCplt;
  /* Set the DMA error callback */
  hhash->hdmain->XferErrorCallback = HASH_DMAError;

  /* Store number of words already pushed to manage proper DMA processing suspension */
  hhash->NbWordsAlreadyPushed = HASH_NBW_PUSHED();

  /* Enable the DMA In DMA stream */
  status = HAL_DMA_Start_IT(hhash->hdmain, inputaddr, (uint32_t)&HASH->DIN, \
                            (((inputSize % 4U) != 0U) ? ((inputSize + (4U - (inputSize % 4U))) / 4U) : \
                             (inputSize / 4U)));

  /* Enable DMA requests */
  SET_BIT(HASH->CR, HASH_CR_DMAE);

  /* Process Unlock */
  __HAL_UNLOCK(hhash);

  /* Return function status */
  if (status != HAL_OK)
  {
    /* Update HASH state machine to error */
    hhash->State = HAL_HASH_STATE_ERROR;
  }

  return status;
}
else
{
  return HAL_BUSY;
}
}
```

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

### HAL_SPDIFRX_MspInit

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__spdifrx_8c_source.html

Weak MSP initialization callback for SPDIFRX.

```APIDOC
## HAL_SPDIFRX_MspInit

### Description
Weak function for SPDIFRX MSP initialization. This function should not be modified; when the callback is needed, it can be implemented in the user file.

### Parameters
- **hspdif** (SPDIFRX_HandleTypeDef*) - Pointer to the SPDIFRX handle.

### Returns
None

### Notes
This is a weak function that can be overridden by the user.
```

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

### LL_ADC internal channel path selection example

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F411xE_User_Manual/stm32f4xx__ll__adc_8h_source.html

Example of selecting internal ADC channels (VrefInt and temperature sensor) using bitwise OR of LL_ADC_PATH_INTERNAL_VREFINT and LL_ADC_PATH_INTERNAL_TEMPSENSOR. Note that a stabilization delay is required after enabling internal paths before starting conversion.

```c
(LL_ADC_PATH_INTERNAL_VREFINT |
                  LL_ADC_PATH_INTERNAL_TEMPSENSOR)
```

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

### HCD Driver Usage Workflow

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F417xx_User_Manual/stm32f4xx__hal__hcd_8c.html

Steps to initialize and start the HCD peripheral, including handle declaration, clock configuration, and NVIC setup.

```c
  ==============================================================================
                    ##### How to use this driver #####
  ==============================================================================
  [..]
    (#)Declare a HCD_HandleTypeDef handle structure, for example:
       HCD_HandleTypeDef  hhcd;

    (#)Fill parameters of Init structure in HCD handle

    (#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)

    (#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
        (##) Enable the HCD/USB Low Level interface clock using the following macros
             (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
             (+++) __HAL_RCC_USB_OTG_HS_CLK_ENABLE(); (For High Speed Mode)
             (+++) __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE(); (For High Speed Mode)

        (##) Initialize the related GPIO clocks
        (##) Configure HCD pin-out
        (##) Configure HCD NVIC interrupt

    (#)Associate the Upper USB Host stack to the HAL HCD Driver:
        (##) hhcd.pData = phost;

    (#)Enable HCD transmission and reception:
        (##) HAL_HCD_Start();
```

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

### HAL PCD Callbacks: Setup, SOF, Reset, Suspend

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/stm32f4xx__hal__pcd_8c_source.html

Weak callback implementations for USB PCD events: setup stage, start of frame, reset, and suspend. Each callback is empty by default and can be overridden in user code to handle the corresponding USB event.

```c
__weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hpcd);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_PCD_SetupStageCallback could be implemented in the user file
   */
}
```

```c
__weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hpcd);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_PCD_SOFCallback could be implemented in the user file
   */
}
```

```c
__weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hpcd);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_PCD_ResetCallback could be implemented in the user file
   */
}
```

```c
__weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hpcd);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_PCD_SuspendCallback could be implemented in the user file
   */
}
```

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

### HAL_SD_Init

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F439xx_User_Manual/globals_func_0x68.html

Initializes the SD card.

```APIDOC
## HAL_SD_Init

### Description
Initializes the SD card.

### Parameters
None

### Returns
None
```

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

### LL_ADC_REG_GetTriggerSource

Source: https://github.com/xywml/stm32f4_hal_doc/blob/main/STM32F410Rx_User_Manual/group__ADC__LL__EF__Configuration__ADC__Group__Regular.html

Get ADC group regular conversion trigger source: internal (SW start) or from external IP (timer event, external interrupt line).

```APIDOC
## LL_ADC_REG_GetTriggerSource

### Description
Get ADC group regular conversion trigger source: internal (SW start) or from external IP (timer event, external interrupt line).

### Function Signature
```c
__STATIC_INLINE uint32_t LL_ADC_REG_GetTriggerSource(const ADC_TypeDef *ADCx)
```

### Parameters
- **ADCx** (const ADC_TypeDef*) - Pointer to the ADC peripheral instance.

### Return Value
uint32_t - Trigger source value. See LL_ADC_REG_TRIG_SOURCE_* definitions.
```
Tokens:
Raw