自学教程：C++ HAL_DMA_Init函数代码示例

/**  * @brief DAC MSP De-Initialization   *        This function frees the hardware resources used in this example:  *          - Disable the Peripheral's clock  *          - Revert GPIO to their default state  * @param hadc: DAC handle pointer  * @retval None  */void HAL_DAC_MspInit(DAC_HandleTypeDef* hdac){  GPIO_InitTypeDef          GPIO_InitStruct;  static DMA_HandleTypeDef  hdma_dac1;      /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* DAC Periph clock enable */  __DAC_CLK_ENABLE();  /* Enable GPIO clock ****************************************/  DACx_CHANNEL1_GPIO_CLK_ENABLE(); /* DMA1 clock enable */  DMAx_CLK_ENABLE();    /*##-2- Configure peripheral GPIO ##########################################*/   /* DAC Channel1 GPIO pin configuration */  GPIO_InitStruct.Pin = DACx_CHANNEL1_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(DACx_CHANNEL1_GPIO_PORT, &GPIO_InitStruct);    /*##-3- Configure the DMA streams ##########################################*/  /* Set the parameters to be configured for Channel1*/  hdma_dac1.Instance = DACx_DMA_STREAM1;    hdma_dac1.Init.Channel  = DACx_DMA_CHANNEL1;  hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH;  hdma_dac1.Init.PeriphInc = DMA_PINC_DISABLE;  hdma_dac1.Init.MemInc = DMA_MINC_ENABLE;  hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;  hdma_dac1.Init.Mode = DMA_CIRCULAR;  hdma_dac1.Init.Priority = DMA_PRIORITY_HIGH;  hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;           hdma_dac1.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;  hdma_dac1.Init.MemBurst = DMA_MBURST_SINGLE;  hdma_dac1.Init.PeriphBurst = DMA_PBURST_SINGLE;   HAL_DMA_Init(&hdma_dac1);    /* Associate the initialized DMA handle to the the DAC handle */  __HAL_LINKDMA(hdac, DMA_Handle1, hdma_dac1);    /*##-4- Configure the NVIC for DMA #########################################*/  /* Enable the DMA1 Stream5 IRQ Channel */  HAL_NVIC_SetPriority(DACx_DMA_IRQn1, 2, 0);  HAL_NVIC_EnableIRQ(DACx_DMA_IRQn1);}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base){  GPIO_InitTypeDef GPIO_InitStruct;  if(htim_base->Instance==TIM2)  {  /* USER CODE BEGIN TIM2_MspInit 0 */  /* USER CODE END TIM2_MspInit 0 */    /* Peripheral clock enable */    __TIM2_CLK_ENABLE();      /**TIM2 GPIO Configuration        PA5     ------> TIM2_CH1     */    GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_LOW;    GPIO_InitStruct.Alternate = GPIO_AF1_TIM2;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_tim2_ch1.Instance = DMA1_Stream5;    hdma_tim2_ch1.Init.Channel = DMA_CHANNEL_3;    hdma_tim2_ch1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_tim2_ch1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_tim2_ch1.Init.MemInc = DMA_MINC_ENABLE;    hdma_tim2_ch1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    hdma_tim2_ch1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;    hdma_tim2_ch1.Init.Mode = DMA_NORMAL;    hdma_tim2_ch1.Init.Priority = DMA_PRIORITY_LOW;    hdma_tim2_ch1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    HAL_DMA_Init(&hdma_tim2_ch1);    __HAL_LINKDMA(htim_base,hdma[TIM_DMA_ID_CC1],hdma_tim2_ch1);  /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);    HAL_NVIC_EnableIRQ(TIM2_IRQn);  /* USER CODE BEGIN TIM2_MspInit 1 */  /* USER CODE END TIM2_MspInit 1 */  }}

/**  * @brief  Configure the DMA controller according to the Channel parameters  *         defined in main.h file  * @note  This function is used to :  *        -1- Enable DMA2 clock  *        -2- Select the DMA functional Parameters  *        -3- Select the DMA instance to be used for the transfer  *        -4- Select Callbacks functions called after Transfer complete and                Transfer error interrupt detection  *        -5- Initialize the DMA Channel  *        -6- Configure NVIC for DMA transfer complete/error interrupts  *        -7- Start the DMA transfer using the interrupt mode  * @param  None  * @retval None  */static void DMA_Config(void){  /*## -1- Enable DMA2 clock #################################################*/  __DMA2_CLK_ENABLE();      /*##-2- Select the DMA functional Parameters ###############################*/  DmaHandle.Init.Direction = DMA_MEMORY_TO_MEMORY;          /* M2M transfer mode                */             DmaHandle.Init.PeriphInc = DMA_PINC_ENABLE;               /* Peripheral increment mode Enable */                   DmaHandle.Init.MemInc = DMA_MINC_ENABLE;                  /* Memory increment mode Enable     */                     DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* Peripheral data alignment : Word */      DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;    /* memory data alignment : Word     */       DmaHandle.Init.Mode = DMA_NORMAL;                         /* Normal DMA mode                  */    DmaHandle.Init.Priority = DMA_PRIORITY_HIGH;              /* priority level : high            */      /*##-3- Select the DMA instance to be used for the transfer : DMA2_Channel1 #*/  DmaHandle.Instance = DMA_CHANNEL;  /*##-4- Select Callbacks functions called after Transfer complete and Transfer error */  DmaHandle.XferCpltCallback  = TransferComplete;  DmaHandle.XferErrorCallback = TransferError;      /*##-5- Initialize the DMA channel ##########################################*/  if(HAL_DMA_Init(&DmaHandle) != HAL_OK)  {    /* Turn LED3 on: in case of Initialization Error */    BSP_LED_On(LED3);    while(1)    {    }  }       /*##-6- Configure NVIC for DMA transfer complete/error interrupts ##########*/  HAL_NVIC_SetPriority(DMA_CHANNEL_IRQ, 0, 0);  HAL_NVIC_EnableIRQ(DMA_CHANNEL_IRQ);  /*##-7- Start the DMA transfer using the interrupt mode ####################*/  /* Configure the source, destination and buffer size DMA fields and Start DMA Channel transfer */  /* Enable All the DMA interrupts */  if(HAL_DMA_Start_IT(&DmaHandle, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)  {    /* Turn LED3 on: Transfer error */    BSP_LED_On(LED3);    while(1)    {    }  }} 

/**  * @brief ADC MSP Initialization   *        This function configures the hardware resources used in this application:   *           - Peripheral's clock enable  *           - Peripheral's GPIO Configuration    * @param hadc: ADC handle pointer  * @retval None  */void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc){  GPIO_InitTypeDef          GPIO_InitStruct;  static DMA_HandleTypeDef  hdma_adc;    /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO clock */  ADCx_CHANNEL_GPIO_CLK_ENABLE();  /* ADC3 Periph clock enable */  ADCx_CLK_ENABLE();  /* Enable DMA2 clock */  DMAx_CLK_ENABLE();     /*##-2- Configure peripheral GPIO ##########################################*/   /* ADC3 Channel8 GPIO pin configuration */  GPIO_InitStruct.Pin = ADCx_CHANNEL_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(ADCx_CHANNEL_GPIO_PORT, &GPIO_InitStruct);    /*##-3- Configure the DMA streams ##########################################*/  /* Set the parameters to be configured */  hdma_adc.Instance = ADCx_DMA_STREAM;    hdma_adc.Init.Channel  = ADCx_DMA_CHANNEL;  hdma_adc.Init.Direction = DMA_PERIPH_TO_MEMORY;  hdma_adc.Init.PeriphInc = DMA_PINC_DISABLE;  hdma_adc.Init.MemInc = DMA_MINC_ENABLE;  hdma_adc.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;  hdma_adc.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;  hdma_adc.Init.Mode = DMA_CIRCULAR;  hdma_adc.Init.Priority = DMA_PRIORITY_HIGH;  hdma_adc.Init.FIFOMode = DMA_FIFOMODE_DISABLE;           hdma_adc.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;  hdma_adc.Init.MemBurst = DMA_MBURST_SINGLE;  hdma_adc.Init.PeriphBurst = DMA_PBURST_SINGLE;   HAL_DMA_Init(&hdma_adc);      /* Associate the initialized DMA handle to the the ADC handle */  __HAL_LINKDMA(hadc, DMA_Handle, hdma_adc);  /*##-4- Configure the NVIC for DMA #########################################*/  /* NVIC configuration for DMA transfer complete interrupt */  HAL_NVIC_SetPriority(ADCx_DMA_IRQn, 5, 0);     HAL_NVIC_EnableIRQ(ADCx_DMA_IRQn);}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc){  GPIO_InitTypeDef GPIO_InitStruct;  if(hadc->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* Peripheral clock enable */    __ADC1_CLK_ENABLE();      /**ADC1 GPIO Configuration        PC0     ------> ADC1_IN10    PC1     ------> ADC1_IN11    PC2     ------> ADC1_IN12    PC3     ------> ADC1_IN13     */    GPIO_InitStruct.Pin = Ain1_Pin|Ain2_Pin|Ain3_Pin|Ain4_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_adc1.Instance = DMA2_Stream0;    hdma_adc1.Init.Channel = DMA_CHANNEL_0;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    hdma_adc1.Init.Mode = DMA_CIRCULAR;    hdma_adc1.Init.Priority = DMA_PRIORITY_MEDIUM;    hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    hdma_adc1.Init.MemBurst = DMA_MBURST_SINGLE;    HAL_DMA_Init(&hdma_adc1);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }}

/*====================================================================================================*/void HAL_ADC_MspInit( ADC_HandleTypeDef *hadc ){  static DMA_HandleTypeDef DMA_HandleStruct;  GPIO_InitTypeDef GPIO_InitStruct;  RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct;  /* Enable clock ******************************************************************/  ADCx_GPIO_CLK_ENABLE();  ADCx_CLK_ENABLE();  ADCx_DMA_CLK_ENABLE();  /* Enable asynchronous clock source of ADCx **************************************/  RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_ADC12;  RCC_PeriphCLKInitStruct.Adc12ClockSelection = RCC_ADC12PLLCLK_DIV1;  HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);  /* Config GPIO ******************************************************************/  GPIO_InitStruct.Pin  = ADCx_GPIO_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(ADCx_GPIO_PORT, &GPIO_InitStruct);  /* Config DMA *****************************************************************/  DMA_HandleStruct.Instance                 = ADCx_DMA_CHANNEL;  DMA_HandleStruct.Init.Direction           = DMA_PERIPH_TO_MEMORY;  DMA_HandleStruct.Init.PeriphInc           = DMA_PINC_DISABLE;  DMA_HandleStruct.Init.MemInc              = DMA_MINC_ENABLE;  DMA_HandleStruct.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;  DMA_HandleStruct.Init.MemDataAlignment    = DMA_MDATAALIGN_HALFWORD;  DMA_HandleStruct.Init.Mode                = DMA_CIRCULAR;  DMA_HandleStruct.Init.Priority            = DMA_PRIORITY_MEDIUM;  HAL_DMA_DeInit(&DMA_HandleStruct);  HAL_DMA_Init(&DMA_HandleStruct);  __HAL_LINKDMA(hadc, DMA_Handle, DMA_HandleStruct);  /* Config NVIC *****************************************************************/  // DMA interrupt - Priority: high-priority  HAL_NVIC_SetPriority(ADCx_DMA_IRQn, 1, 0);  HAL_NVIC_EnableIRQ(ADCx_DMA_IRQn);  // ADC interrupt - Priority: high-priority  HAL_NVIC_SetPriority(ADCx_IRQn, 0, 0);  HAL_NVIC_EnableIRQ(ADCx_IRQn);}

void APP_ADC_Init(ADC_HandleTypeDef *hadc){  GPIO_InitTypeDef                 GPIO_InitStruct;  static DMA_HandleTypeDef         DmaHandle;  /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO clock ****************************************/  __GPIOA_CLK_ENABLE();  /* ADC1 Periph clock enable */ __ADC1_CLK_ENABLE();  /* Enable DMA1 clock */  __DMA1_CLK_ENABLE();  /*##- 2- Configure peripheral GPIO #########################################*/  /* ADC3 Channel8 GPIO pin configuration */  GPIO_InitStruct.Pin = GPIO_PIN_0| GPIO_PIN_1;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);  /*##- 3- Configure DMA #####################################################*/  /*********************** Configure DMA parameters ***************************/  DmaHandle.Instance                 = DMA1_Channel1;  DmaHandle.Init.Direction           = DMA_PERIPH_TO_MEMORY;  DmaHandle.Init.PeriphInc           = DMA_PINC_DISABLE;  DmaHandle.Init.MemInc              = DMA_MINC_ENABLE;  DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;  DmaHandle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;  DmaHandle.Init.Mode                = DMA_CIRCULAR;  DmaHandle.Init.Priority            = DMA_PRIORITY_MEDIUM;  DmaHandle.Init.Request             = DMA_REQUEST_0;  /* Deinitialize  & Initialize the DMA for new transfer */  HAL_DMA_DeInit(&DmaHandle);  HAL_DMA_Init(&DmaHandle);  /* Associate the DMA handle */  __HAL_LINKDMA(hadc, DMA_Handle, DmaHandle);  /* NVIC configuration for DMA Input data interrupt */  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1, 0);  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc){  GPIO_InitTypeDef GPIO_InitStruct;  if(hadc->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* Peripheral clock enable */    __ADC1_CLK_ENABLE();      /**ADC1 GPIO Configuration        PA0-WKUP     ------> ADC1_IN0    PA1     ------> ADC1_IN1     */    GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_adc1.Instance = DMA2_Stream0;    hdma_adc1.Init.Channel = DMA_CHANNEL_0;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;    hdma_adc1.Init.Mode = DMA_CIRCULAR;    hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;    hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    HAL_DMA_Init(&hdma_adc1);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(ADC_IRQn);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }}

/**  * @brief ADC MSP Initialization  *        This function configures the hardware resources used in this example:  *          - Configuration of peripheral clock  *          - Configuration of GPIO associated to the peripheral channels  *          - Configuration of DMA  *          - Configuration of interruptions  * @param huart: UART handle pointer  * @retval None  */void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc){  GPIO_InitTypeDef          GPIO_InitStruct;  static DMA_HandleTypeDef  hdma_adc;  /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO clock */  ADCxy_CHANNEL_GPIO_CLK_ENABLE();  /* ADCx Periph clock enable */  ADCx_CLK_ENABLE();  /* ADCy Periph clock enable */  ADCy_CLK_ENABLE();  /* Enable DMA clock */  DMAxy_CLK_ENABLE();  /*##-2- Configure peripheral GPIO ##########################################*/  /* ADCx and ADCy Channel GPIO pin configuration */  GPIO_InitStruct.Pin = ADCxy_CHANNEL_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(ADCxy_CHANNEL_GPIO_PORT, &GPIO_InitStruct);  /*##-3- Configure the DMA channels ##########################################*/  /* Set the parameters to be configured */  hdma_adc.Instance = ADCxy_DMA_STREAM;                         /* DMA channel of ADC1 (ADC master) */  hdma_adc.Init.Direction = DMA_PERIPH_TO_MEMORY;  hdma_adc.Init.PeriphInc = DMA_PINC_DISABLE;  hdma_adc.Init.MemInc = DMA_MINC_ENABLE;  hdma_adc.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;  /* Transfer by half-word to match with ADC resolution 6 or 8 bits */  hdma_adc.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;     /* Transfer by half-word to match with ADC resolution 6 or 8 bits */  hdma_adc.Init.Mode = DMA_CIRCULAR;                            /* DMA in circular mode to match with ADC-DMA continuous requests */  hdma_adc.Init.Priority = DMA_PRIORITY_HIGH;  HAL_DMA_Init(&hdma_adc);  /* Associate the initialized DMA handle to the the ADC handle */  __HAL_LINKDMA(hadc, DMA_Handle, hdma_adc);  /*##-4- Configure the NVIC for DMA #########################################*/  /* NVIC configuration for DMA transfer complete interrupt */  HAL_NVIC_SetPriority(ADCxy_DMA_IRQn, 0, 0);  HAL_NVIC_EnableIRQ(ADCxy_DMA_IRQn);}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc) {  if(hadc->Instance==ADC1)  {    /* Peripheral clock enable */    __HAL_RCC_ADC1_CLK_ENABLE();    /* Peripheral DMA init*/    hdma_adc1.Instance = DMA1_Channel1;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    hdma_adc1.Init.Mode = DMA_NORMAL;    hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_Init(&hdma_adc1);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);  }}

void HAL_DAC_MspInit(DAC_HandleTypeDef* hdac){  GPIO_InitTypeDef GPIO_InitStruct;  if(hdac->Instance==DAC)  {  /* USER CODE BEGIN DAC_MspInit 0 */  /* USER CODE END DAC_MspInit 0 */    /* Peripheral clock enable */    __DAC_CLK_ENABLE();      /**DAC GPIO Configuration        PA5     ------> DAC_OUT2     */    GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_dac2.Instance = DMA1_Stream6;    hdma_dac2.Init.Channel = DMA_CHANNEL_7;    hdma_dac2.Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma_dac2.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_dac2.Init.MemInc = DMA_MINC_ENABLE;    hdma_dac2.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    hdma_dac2.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;    hdma_dac2.Init.Mode = DMA_CIRCULAR;    hdma_dac2.Init.Priority = DMA_PRIORITY_VERY_HIGH;    hdma_dac2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    HAL_DMA_Init(&hdma_dac2);    __HAL_LINKDMA(hdac,DMA_Handle2,hdma_dac2);  /* USER CODE BEGIN DAC_MspInit 1 */  /* USER CODE END DAC_MspInit 1 */  }}

void dma_init(DMA_HandleTypeDef *dma, DMA_Stream_TypeDef *dma_stream, const DMA_InitTypeDef *dma_init, uint32_t dma_channel, uint32_t direction, void *data) {    int dma_id = get_dma_id(dma_stream);    //printf("dma_init(%p, %p(%d), 0x%x, 0x%x, %p)/n", dma, dma_stream, dma_id, (uint)dma_channel, (uint)direction, data);    // TODO possibly don't need to clear the entire structure    memset(dma, 0, sizeof(*dma));    // set global pointer for IRQ handler    dma_handle[dma_id] = dma;    // initialise parameters    dma->Instance = dma_stream;    dma->Init = *dma_init;    dma->Init.Direction = direction;    dma->Init.Channel = dma_channel;    // half of __HAL_LINKDMA(data, xxx, *dma)    // caller must implement other half by doing: data->xxx = dma    dma->Parent = data;    // if this stream was previously configured for this channel then we    // can skip most of the initialisation    if (dma_last_channel[dma_id] == dma_channel) {        goto same_channel;    }    dma_last_channel[dma_id] = dma_channel;    // enable clock for needed DMA peripheral    if (dma_id <= 7) {        __DMA1_CLK_ENABLE();    } else {        __DMA2_CLK_ENABLE();    }    // reset and configure DMA peripheral    HAL_DMA_DeInit(dma);    HAL_DMA_Init(dma);    HAL_NVIC_SetPriority(dma_irqn[dma_id], 6, 0);same_channel:    HAL_NVIC_EnableIRQ(dma_irqn[dma_id]);}

void TM_DMA_Init(DMA_Stream_TypeDef* Stream, DMA_HandleTypeDef* HDMA) {		/* Init DMA stream */	if (HDMA) {		/* Unlock DMA */		__HAL_UNLOCK(HDMA);				/* Init DMA */		HDMA->Instance = Stream;		HAL_DMA_Init(HDMA);	} else {		/* Enable DMA clock */		if (Stream >= DMA2_Stream0) {			/* Enable DMA2 clock */				RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;		} else {			/* Enable DMA1 clock */			RCC->AHB1ENR |= RCC_AHB1ENR_DMA1EN;		}	}}

void Uart2DMAInit(UART_HandleTypeDef* huart) {	__HAL_RCC_DMA1_CLK_ENABLE()	;    huart->hdmatx = (DMA_HandleTypeDef *)calloc(1, sizeof(DMA_HandleTypeDef));    REQUIRE(huart->hdmatx != 0);    huart->hdmatx->Instance = DMA1_Channel7;    huart->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;    huart->hdmatx->Init.PeriphInc = DMA_PINC_DISABLE;    huart->hdmatx->Init.MemInc = DMA_MINC_ENABLE;    huart->hdmatx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    huart->hdmatx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    huart->hdmatx->Init.Mode = DMA_NORMAL;    huart->hdmatx->Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_Init(huart->hdmatx);    huart->hdmatx->Parent = huart;	HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0);	HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc){  GPIO_InitTypeDef GPIO_InitStruct;  if(hadc->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* Peripheral clock enable */    __ADC1_CLK_ENABLE();      /**ADC GPIO Configuration        PA0     ------> ADC_IN0    PA1     ------> ADC_IN1     */    GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_adc.Instance = DMA1_Channel1;    hdma_adc.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    hdma_adc.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    hdma_adc.Init.Mode = DMA_CIRCULAR;    hdma_adc.Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_Init(&hdma_adc);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }}

/**  * @brief SD_DMAConfigTx  * @par Function Description  *   This function configure the DMA to transmit data to the SD card  * @retval  *  SD_ERROR or SD_OK  */HAL_SD_ErrorTypedef SD_DMAConfigTx(SD_HandleTypeDef *hsd){  static DMA_HandleTypeDef hdma_tx;  HAL_StatusTypeDef status;  if(hsd->hdmatx == NULL)  {    /* Configure DMA Tx parameters */    hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;    hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;    hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;    hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;    hdma_tx.Init.Priority            = DMA_PRIORITY_VERY_HIGH;    hdma_tx.Instance = SD_DMAx_Tx_INSTANCE;    /* Associate the DMA handle */    __HAL_LINKDMA(hsd, hdmatx, hdma_tx);    /* Stop any ongoing transfer and reset the state*/    HAL_DMA_Abort(&hdma_tx);    /* Deinitialize the Channel for new transfer */    HAL_DMA_DeInit(&hdma_tx);    /* Configure the DMA Channel */    status = HAL_DMA_Init(&hdma_tx);    /* NVIC configuration for DMA transfer complete interrupt */    HAL_NVIC_SetPriority(SD_DMAx_Tx_IRQn, 1, 0);    HAL_NVIC_EnableIRQ(SD_DMAx_Tx_IRQn);  }  else  {    status = HAL_OK;  }  return (status != HAL_OK? SD_ERROR : SD_OK);}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc){  GPIO_InitTypeDef GPIO_InitStruct;  if(hadc->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* Peripheral clock enable */    __ADC1_CLK_ENABLE();      /**ADC1 GPIO Configuration        PB0     ------> ADC1_IN8    PB1     ------> ADC1_IN9     */    GPIO_InitStruct.Pin = keyboard_l_Pin|keyboard_r_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_adc1.Instance = DMA1_Channel1;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    hdma_adc1.Init.Mode = DMA_NORMAL;    hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_Init(&hdma_adc1);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }}

DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size){    SPI_HandleTypeDef* hspi = &spiHandle[spiDeviceByInstance(Instance)].Handle;    DMA_HandleTypeDef* hdma = &dmaHandle[spiDeviceByInstance(Instance)].Handle;    hdma->Instance = Stream;    hdma->Init.Channel = Channel;    hdma->Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma->Init.PeriphInc = DMA_PINC_DISABLE;    hdma->Init.MemInc = DMA_MINC_ENABLE;    hdma->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma->Init.Mode = DMA_NORMAL;    hdma->Init.FIFOMode = DMA_FIFOMODE_DISABLE;    hdma->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;    hdma->Init.PeriphBurst = DMA_PBURST_SINGLE;    hdma->Init.MemBurst = DMA_MBURST_SINGLE;    hdma->Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_DeInit(hdma);    HAL_DMA_Init(hdma);    __HAL_DMA_ENABLE(hdma);    __HAL_SPI_ENABLE(hspi);    /* Associate the initialized DMA handle to the spi handle */    __HAL_LINKDMA(hspi, hdmatx, (*hdma));    // DMA TX Interrupt    dmaSetHandler(DMA2_ST1_HANDLER, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)spiDeviceByInstance(Instance));   // SCB_CleanDCache_by_Addr((uint32_t) pData, Size);    HAL_SPI_Transmit_DMA(hspi, pData, Size);    //HAL_DMA_Start(&hdma, (uint32_t) pData, (uint32_t) &(Instance->DR), Size);    return hdma;}

static voidstm32f4_adc_dma_init(ADC_HandleTypeDef* hadc){    DMA_HandleTypeDef *hdma;    assert(hadc);    hdma = hadc->DMA_Handle;    stm32f4_adc_clk_enable(hadc);    __HAL_RCC_DMA2_CLK_ENABLE();    HAL_DMA_Init(hdma);    dma_handle[stm32f4_resolve_dma_handle_idx(hdma)] = hdma;    NVIC_SetPriority(stm32f4_resolve_adc_dma_irq(hdma),                     NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 0, 0));    NVIC_SetVector(stm32f4_resolve_adc_dma_irq(hdma),                   stm32f4_resolve_adc_dma_irq_handler(hdma));    NVIC_EnableIRQ(stm32f4_resolve_adc_dma_irq(hdma));}

void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc){  if(hadc->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_ADC1_CLK_ENABLE();    /* Peripheral DMA init*/      hdma_adc1.Instance = DMA2_Stream0;    hdma_adc1.Init.Channel = DMA_CHANNEL_0;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;    hdma_adc1.Init.Mode = DMA_NORMAL;    hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;    hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_ENABLE;    hdma_adc1.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;    hdma_adc1.Init.MemBurst = DMA_MBURST_INC4;    hdma_adc1.Init.PeriphBurst = DMA_PBURST_SINGLE;    HAL_DMA_Init(&hdma_adc1);    __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(ADC_IRQn);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }}

/** * Initialize the UART to communicate with the Skywire modem. */voidskywire_init() {	/* Configure the UART for the Skywire modem. */	__HAL_RCC_USART1_CLK_ENABLE();	skywire.huart.Instance = USART1;	skywire.huart.State = HAL_UART_STATE_RESET;	skywire.huart.Init.BaudRate = 115200;	skywire.huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;	skywire.huart.Init.Mode = UART_MODE_TX_RX;	skywire.huart.Init.WordLength = UART_WORDLENGTH_8B;	skywire.huart.Init.Parity = UART_PARITY_NONE;	skywire.huart.Init.StopBits = UART_STOPBITS_1;	skywire.huart.Init.OverSampling = UART_OVERSAMPLING_16;	HAL_UART_Init(&skywire.huart);	/* Configure a DMA channel to service the UART. */	__HAL_RCC_DMA2_CLK_ENABLE();	skywire.hdma.Instance = DMA2_Stream5;	skywire.hdma.State = HAL_DMA_STATE_RESET;	skywire.hdma.Init.Channel = DMA_CHANNEL_4;	skywire.hdma.Init.Direction = DMA_PERIPH_TO_MEMORY;	skywire.hdma.Init.PeriphInc = DMA_PINC_DISABLE;	skywire.hdma.Init.MemInc = DMA_MINC_ENABLE;	skywire.hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;	skywire.hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;	skywire.hdma.Init.Mode = DMA_CIRCULAR;	skywire.hdma.Init.Priority = DMA_PRIORITY_LOW;	skywire.hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;	skywire.hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;	skywire.hdma.Init.MemBurst = DMA_MBURST_SINGLE;	skywire.hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;	HAL_DMA_Init(&skywire.hdma);	__HAL_LINKDMA(&skywire.huart, hdmarx, skywire.hdma);	/* Start the receive process. */	HAL_UART_Receive_DMA(&skywire.huart, skywire.rx_buffer, skywire.rx_length);}

/**  * @brief  Initializes the HASH MSP.  *        This function configures the hardware resources used in this example:  *           - HASH's clock enable  *           - DMA's clocks enable  * @param  hhash: HASH handle pointer  * @retval None  */void HAL_HASH_MspInit(HASH_HandleTypeDef *hhash){  static DMA_HandleTypeDef  hdma_hash;  /* Enable HASH clock */  __HAL_RCC_HASH_CLK_ENABLE();  /* Enable DMA clocks */  DMA_CLK_ENABLE();  /***************** Configure common DMA In parameters ***********************/  hdma_hash.Init.Channel             = HASH_DMA_CHANNEL;  hdma_hash.Init.Direction           = DMA_MEMORY_TO_PERIPH;  hdma_hash.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_hash.Init.MemInc              = DMA_MINC_ENABLE;  hdma_hash.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;  hdma_hash.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;  hdma_hash.Init.Mode                = DMA_NORMAL;  hdma_hash.Init.Priority            = DMA_PRIORITY_HIGH;  hdma_hash.Init.FIFOMode            = DMA_FIFOMODE_ENABLE;  hdma_hash.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_HALFFULL;  hdma_hash.Init.MemBurst            = DMA_MBURST_SINGLE;  hdma_hash.Init.PeriphBurst         = DMA_PBURST_SINGLE;  hdma_hash.Instance = HASH_DMA_STREAM;  /* Associate the DMA handle */  __HAL_LINKDMA(hhash, hdmain, hdma_hash);  /* Deinitialize the Stream for new transfer */  HAL_DMA_DeInit(hhash->hdmain);  /* Configure the DMA Stream */  HAL_DMA_Init(hhash->hdmain);  /* NVIC configuration for DMA Input data interrupt */  HAL_NVIC_SetPriority(HASH_DMA_IRQn, 0x0F, 0x0f);  HAL_NVIC_EnableIRQ(HASH_DMA_IRQn);}

static int reinit_sai_and_dma(SAI_DIRECTION dir){	static SAI_DIRECTION sai_dma_status = SAI_dir_tx_m2p;	if (dir == sai_dma_status)		return 0;	switch (dir) {		case SAI_dir_tx_m2p:			hal_gpio_output_high(&brd_gpio_table[GPIO_AUDIO_EN]);			break;		case SAI_dir_rx_p2m:			hal_gpio_output_low(&brd_gpio_table[GPIO_AUDIO_EN]);			break;		default:			KIDS_A10_PRT("Parameters is invalied, dir: %d/n", dir);			return -1;	}	hsai_BlockA1.Init.AudioMode = (dir == SAI_dir_tx_m2p ? SAI_MODEMASTER_TX : SAI_MODEMASTER_RX);	hsai_BlockA1.Init.ClockStrobing = (dir == SAI_dir_tx_m2p ? SAI_CLOCKSTROBING_FALLINGEDGE : SAI_CLOCKSTROBING_RISINGEDGE);	if (HAL_SAI_Init(&hsai_BlockA1) != HAL_OK)	{		KIDS_A10_PRT("HAL_SAI_Init return failed./n");		return -1;	}	hdma_sai1_a.Init.Direction = (dir == SAI_dir_tx_m2p ? DMA_MEMORY_TO_PERIPH : DMA_PERIPH_TO_MEMORY);	if (HAL_DMA_Init(&hdma_sai1_a) != HAL_OK)	{		KIDS_A10_PRT("HAL_DMA_Init return failed./n");		return -1;	}	sai_dma_status = dir;	return 0;}

DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size){    SPIDevice device = spiDeviceByInstance(Instance);    spiHardwareMap[device].hdma.Instance = Stream;    spiHardwareMap[device].hdma.Init.Channel = Channel;    spiHardwareMap[device].hdma.Init.Direction = DMA_MEMORY_TO_PERIPH;    spiHardwareMap[device].hdma.Init.PeriphInc = DMA_PINC_DISABLE;    spiHardwareMap[device].hdma.Init.MemInc = DMA_MINC_ENABLE;    spiHardwareMap[device].hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    spiHardwareMap[device].hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    spiHardwareMap[device].hdma.Init.Mode = DMA_NORMAL;    spiHardwareMap[device].hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    spiHardwareMap[device].hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;    spiHardwareMap[device].hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;    spiHardwareMap[device].hdma.Init.MemBurst = DMA_MBURST_SINGLE;    spiHardwareMap[device].hdma.Init.Priority = DMA_PRIORITY_LOW;    HAL_DMA_DeInit(&spiHardwareMap[device].hdma);    HAL_DMA_Init(&spiHardwareMap[device].hdma);    __HAL_DMA_ENABLE(&spiHardwareMap[device].hdma);    __HAL_SPI_ENABLE(&spiHardwareMap[device].hspi);    /* Associate the initialized DMA handle to the spi handle */    __HAL_LINKDMA(&spiHardwareMap[device].hspi, hdmatx, spiHardwareMap[device].hdma);    // DMA TX Interrupt    dmaSetHandler(spiHardwareMap[device].dmaIrqHandler, dmaSPIIRQHandler, NVIC_BUILD_PRIORITY(3, 0), (uint32_t)device);    //HAL_CLEANCACHE(pData,Size);    // And Transmit    HAL_SPI_Transmit_DMA(&spiHardwareMap[device].hspi, pData, Size);    return &spiHardwareMap[device].hdma;}

void Uart6DMAInit(UART_HandleTypeDef* huart) {	__DMA2_CLK_ENABLE();	huart->hdmatx = (DMA_HandleTypeDef*) calloc(1, sizeof(DMA_HandleTypeDef));	REQUIRE(huart->hdmatx!=0);	huart->hdmatx->Instance = DMA2_Stream6;	huart->hdmatx->Init.Channel = DMA_CHANNEL_5;	huart->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;	huart->hdmatx->Init.PeriphInc = DMA_PINC_DISABLE;	huart->hdmatx->Init.MemInc = DMA_MINC_ENABLE;	huart->hdmatx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;	huart->hdmatx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;	huart->hdmatx->Init.Mode = DMA_NORMAL;	huart->hdmatx->Init.Priority = DMA_PRIORITY_LOW;	huart->hdmatx->Init.FIFOMode = DMA_FIFOMODE_DISABLE;	huart->hdmatx->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;	huart->hdmatx->Init.MemBurst = DMA_MBURST_SINGLE;	huart->hdmatx->Init.PeriphBurst = DMA_PBURST_SINGLE;	HAL_DMA_Init(huart->hdmatx);	huart->hdmatx->Parent = huart;	HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0, 0);	HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);}

void HAL_UART_MspInit(UART_HandleTypeDef* huart){    GPIO_InitTypeDef GPIO_InitStruct;    if(huart->Instance==USART2)    {        /* USER CODE BEGIN USART2_MspInit 0 */        /* USER CODE END USART2_MspInit 0 */        /* Peripheral clock enable */        __USART2_CLK_ENABLE();        /**USART2 GPIO Configuration        PA2     ------> USART2_TX        PA3     ------> USART2_RX        */        GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;        GPIO_InitStruct.Pull = GPIO_PULLUP;        GPIO_InitStruct.Speed = GPIO_SPEED_LOW;        GPIO_InitStruct.Alternate = GPIO_AF7_USART2;        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);        /* Peripheral DMA init*/        hdma_usart2_rx.Instance = DMA1_Stream5;        hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;        hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;        hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;        hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;        hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;        hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;        hdma_usart2_rx.Init.Mode = DMA_NORMAL;        hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW;        hdma_usart2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;        HAL_DMA_Init(&hdma_usart2_rx);        __HAL_LINKDMA(huart,hdmarx,hdma_usart2_rx);        hdma_usart2_tx.Instance = DMA1_Stream6;        hdma_usart2_tx.Init.Channel = DMA_CHANNEL_4;        hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;        hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE;        hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE;        hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;        hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;        hdma_usart2_tx.Init.Mode = DMA_NORMAL;        hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW;        hdma_usart2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;        HAL_DMA_Init(&hdma_usart2_tx);        __HAL_LINKDMA(huart,hdmatx,hdma_usart2_tx);        /* Peripheral interrupt init*/        HAL_NVIC_SetPriority(USART2_IRQn, 1, 0);        HAL_NVIC_EnableIRQ(USART2_IRQn);        /* USER CODE BEGIN USART2_MspInit 1 */        __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE); //|UART_IT_IDLE        /* USER CODE END USART2_MspInit 1 */    }    else if(huart->Instance==USART3)    {        /* USER CODE BEGIN USART3_MspInit 0 */        /* USER CODE END USART3_MspInit 0 */        /* Peripheral clock enable */        __USART3_CLK_ENABLE();        /**USART3 GPIO Configuration        PD8     ------> USART3_TX        PD9     ------> USART3_RX        */        GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;        GPIO_InitStruct.Pull = GPIO_PULLUP;        GPIO_InitStruct.Speed = GPIO_SPEED_LOW;        GPIO_InitStruct.Alternate = GPIO_AF7_USART3;        HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);        /* Peripheral DMA init*/        hdma_usart3_rx.Instance = DMA1_Stream1;        hdma_usart3_rx.Init.Channel = DMA_CHANNEL_4;        hdma_usart3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;        hdma_usart3_rx.Init.PeriphInc = DMA_PINC_DISABLE;        hdma_usart3_rx.Init.MemInc = DMA_MINC_ENABLE;        hdma_usart3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;        hdma_usart3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;        hdma_usart3_rx.Init.Mode = DMA_CIRCULAR;        hdma_usart3_rx.Init.Priority = DMA_PRIORITY_LOW;        hdma_usart3_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;        HAL_DMA_Init(&hdma_usart3_rx);        __HAL_LINKDMA(huart,hdmarx,hdma_usart3_rx);        /* Peripheral interrupt init*/        HAL_NVIC_SetPriority(USART3_IRQn, 2, 0);        HAL_NVIC_EnableIRQ(USART3_IRQn);//.........这里部分代码省略.........

static void init_uart(serial_t *obj){#if DEVICE_SERIAL_ASYNCH_DMA    static DMA_HandleTypeDef hdma_tx;    static DMA_HandleTypeDef hdma_rx;#endif    UartHandle.Instance = (USART_TypeDef *)(SERIAL_OBJ(uart));    UartHandle.Init.BaudRate     = SERIAL_OBJ(baudrate);    UartHandle.Init.WordLength   = SERIAL_OBJ(databits);    UartHandle.Init.StopBits     = SERIAL_OBJ(stopbits);    UartHandle.Init.Parity       = SERIAL_OBJ(parity);    UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;    UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;    if (SERIAL_OBJ(pin_rx) == NC) {        UartHandle.Init.Mode = UART_MODE_TX;    } else if (SERIAL_OBJ(pin_tx) == NC) {        UartHandle.Init.Mode = UART_MODE_RX;    } else {        UartHandle.Init.Mode = UART_MODE_TX_RX;    }#if DEVICE_SERIAL_ASYNCH_DMA    if (SERIAL_OBJ(pin_tx) != NC) {        // set DMA in the UartHandle        /* Configure the DMA handler for Transmission process */        hdma_tx.Instance                 = (DMA_Stream_TypeDef *)DMA_UartTx_Stream[SERIAL_OBJ(index)];        hdma_tx.Init.Channel             = DMA_UartTx_Channel[SERIAL_OBJ(index)];        hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;        hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;        hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;        hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;        hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;        hdma_tx.Init.Mode                = DMA_NORMAL;        hdma_tx.Init.Priority            = DMA_PRIORITY_LOW;        hdma_tx.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;        hdma_tx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;        hdma_tx.Init.MemBurst            = DMA_MBURST_INC4;        hdma_tx.Init.PeriphBurst         = DMA_PBURST_INC4;        HAL_DMA_Init(&hdma_tx);        /* Associate the initialized DMA handle to the UART handle */        __HAL_LINKDMA(&UartHandle, hdmatx, hdma_tx);    }        if (SERIAL_OBJ(pin_rx) != NC) {        /* Configure the DMA handler for reception process */        hdma_rx.Instance                 = (DMA_Stream_TypeDef *)DMA_UartRx_Stream[SERIAL_OBJ(index)];        hdma_rx.Init.Channel             = DMA_UartRx_Channel[SERIAL_OBJ(index)];        hdma_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;        hdma_rx.Init.PeriphInc           = DMA_PINC_DISABLE;        hdma_rx.Init.MemInc              = DMA_MINC_ENABLE;        hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;        hdma_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;        hdma_rx.Init.Mode                = DMA_NORMAL;        hdma_rx.Init.Priority            = DMA_PRIORITY_HIGH;        hdma_rx.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;        hdma_rx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;        hdma_rx.Init.MemBurst            = DMA_MBURST_INC4;        hdma_rx.Init.PeriphBurst         = DMA_PBURST_INC4;        HAL_DMA_Init(&hdma_rx);        /* Associate the initialized DMA handle to the UART handle */        __HAL_LINKDMA(&UartHandle, hdmarx, hdma_rx);    }#endif    if (HAL_UART_Init(&UartHandle) != HAL_OK) {        error("Cannot initialize UART/n");    }}

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi){  GPIO_InitTypeDef GPIO_InitStruct;  if(hspi->Instance==SPI2)  {  /* USER CODE BEGIN SPI2_MspInit 0 */  /* USER CODE END SPI2_MspInit 0 */    /* Peripheral clock enable */    __SPI2_CLK_ENABLE();      /**SPI2 GPIO Configuration        PC2     ------> SPI2_MISO    PC3     ------> SPI2_MOSI    PB10     ------> SPI2_SCK     */    GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);    GPIO_InitStruct.Pin = GPIO_PIN_10;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_spi2_tx.Instance = DMA1_Stream4;    hdma_spi2_tx.Init.Channel = DMA_CHANNEL_0;    hdma_spi2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma_spi2_tx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_spi2_tx.Init.MemInc = DMA_MINC_ENABLE;    hdma_spi2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_spi2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_spi2_tx.Init.Mode = DMA_NORMAL;    hdma_spi2_tx.Init.Priority = DMA_PRIORITY_LOW;    hdma_spi2_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    hdma_spi2_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;    hdma_spi2_tx.Init.MemBurst = DMA_MBURST_SINGLE;    hdma_spi2_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;    HAL_DMA_Init(&hdma_spi2_tx);    __HAL_LINKDMA(hspi,hdmatx,hdma_spi2_tx);    hdma_spi2_rx.Instance = DMA1_Stream3;    hdma_spi2_rx.Init.Channel = DMA_CHANNEL_0;    hdma_spi2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_spi2_rx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_spi2_rx.Init.MemInc = DMA_MINC_ENABLE;    hdma_spi2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_spi2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_spi2_rx.Init.Mode = DMA_NORMAL;    hdma_spi2_rx.Init.Priority = DMA_PRIORITY_LOW;    hdma_spi2_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    hdma_spi2_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;    hdma_spi2_rx.Init.MemBurst = DMA_MBURST_SINGLE;    hdma_spi2_rx.Init.PeriphBurst = DMA_PBURST_SINGLE;    HAL_DMA_Init(&hdma_spi2_rx);    __HAL_LINKDMA(hspi,hdmarx,hdma_spi2_rx);  /* USER CODE BEGIN SPI2_MspInit 1 */  /* USER CODE END SPI2_MspInit 1 */  }}

void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle){  GPIO_InitTypeDef GPIO_InitStruct;  if(adcHandle->Instance==ADC1)  {  /* USER CODE BEGIN ADC1_MspInit 0 */  /* USER CODE END ADC1_MspInit 0 */    /* ADC1 clock enable */    __HAL_RCC_ADC1_CLK_ENABLE();      /**ADC1 GPIO Configuration        PC0     ------> ADC1_IN10    PC1     ------> ADC1_IN11    PC2     ------> ADC1_IN12    PC3     ------> ADC1_IN13    PA4     ------> ADC1_IN4    PA5     ------> ADC1_IN5    PA6     ------> ADC1_IN6    PC4     ------> ADC1_IN14    PC5     ------> ADC1_IN15     */    GPIO_InitStruct.Pin = M0_IB_Pin|M0_IC_Pin|M1_IC_Pin|M1_IB_Pin                           |AUX_TEMP_Pin|M0_TEMP_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);    GPIO_InitStruct.Pin = M1_TEMP_Pin|AUX_I_Pin|VBUS_S_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* ADC1 DMA Init */    /* ADC1 Init */    hdma_adc1.Instance = DMA2_Stream0;    hdma_adc1.Init.Channel = DMA_CHANNEL_0;    hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;    hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;    hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;    hdma_adc1.Init.Mode = DMA_CIRCULAR;    hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;    hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)    {      _Error_Handler(__FILE__, __LINE__);    }    __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);    /* ADC1 interrupt Init */    HAL_NVIC_SetPriority(ADC_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(ADC_IRQn);  /* USER CODE BEGIN ADC1_MspInit 1 */  /* USER CODE END ADC1_MspInit 1 */  }  else if(adcHandle->Instance==ADC2)  {  /* USER CODE BEGIN ADC2_MspInit 0 */  /* USER CODE END ADC2_MspInit 0 */    /* ADC2 clock enable */    __HAL_RCC_ADC2_CLK_ENABLE();      /**ADC2 GPIO Configuration        PC0     ------> ADC2_IN10    PC1     ------> ADC2_IN11    PC2     ------> ADC2_IN12    PC3     ------> ADC2_IN13    PA4     ------> ADC2_IN4    PA5     ------> ADC2_IN5    PA6     ------> ADC2_IN6    PC4     ------> ADC2_IN14    PC5     ------> ADC2_IN15     */    GPIO_InitStruct.Pin = M0_IB_Pin|M0_IC_Pin|M1_IC_Pin|M1_IB_Pin                           |AUX_TEMP_Pin|M0_TEMP_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);    GPIO_InitStruct.Pin = M1_TEMP_Pin|AUX_I_Pin|VBUS_S_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* ADC2 interrupt Init */    HAL_NVIC_SetPriority(ADC_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(ADC_IRQn);  /* USER CODE BEGIN ADC2_MspInit 1 */  /* USER CODE END ADC2_MspInit 1 */  }  else if(adcHandle->Instance==ADC3)  {  /* USER CODE BEGIN ADC3_MspInit 0 *///.........这里部分代码省略.........