/** * @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 void stm32f4_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 */ } }
void traceUartMspInit(UART_HandleTypeDef* pUart) { static DMA_HandleTypeDef hdma_tx; GPIO_InitTypeDef gpioInitStruct; TRACE_UART_TX_GPIO_CLK_ENABLE(); TRACE_UART_CLK_ENABLE(); TRACE_DMA_CLK_ENABLE(); gpioInitStruct.Pin = TRACE_UART_TX_PIN; gpioInitStruct.Mode = GPIO_MODE_AF_PP; gpioInitStruct.Pull = GPIO_PULLUP; gpioInitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; gpioInitStruct.Alternate = TRACE_UART_TX_AF; HAL_GPIO_Init(TRACE_UART_TX_GPIO_PORT, &gpioInitStruct); hdma_tx.Instance = TRACE_UART_TX_DMA_CHANNEL; 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.Request = TRACE_UART_TX_DMA_REQUEST; HAL_DMA_Init(&hdma_tx); __HAL_LINKDMA(pUart, hdmatx, hdma_tx); HAL_NVIC_SetPriority(TRACE_UART_DMA_TX_IRQn, 0, 0); HAL_NVIC_EnableIRQ(TRACE_UART_DMA_TX_IRQn); HAL_NVIC_SetPriority(TRACE_UART_IRQn, 0, 0); HAL_NVIC_EnableIRQ(TRACE_UART_IRQn); }
/** * Initialize the UART to communicate with the Skywire modem. */ void skywire_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); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } else if(huart->Instance==USART6) { /* USER CODE BEGIN USART6_MspInit 0 */ /* USER CODE END USART6_MspInit 0 */ /* Peripheral clock enable */ __USART6_CLK_ENABLE(); /**USART6 GPIO Configuration PC6 ------> USART6_TX PC7 ------> USART6_RX */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF8_USART6; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* USER CODE BEGIN USART6_MspInit 1 */ /* USER CODE END USART6_MspInit 1 */ } }
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 */ /* USER CODE END ADC3_MspInit 0 */ /* ADC3 clock enable */ __HAL_RCC_ADC3_CLK_ENABLE(); /**ADC3 GPIO Configuration PC0 ------> ADC3_IN10 PC1 ------> ADC3_IN11 PC2 ------> ADC3_IN12 PC3 ------> ADC3_IN13 */ GPIO_InitStruct.Pin = M0_IB_Pin|M0_IC_Pin|M1_IC_Pin|M1_IB_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* ADC3 interrupt Init */ HAL_NVIC_SetPriority(ADC_IRQn, 5, 0); HAL_NVIC_EnableIRQ(ADC_IRQn); /* USER CODE BEGIN ADC3_MspInit 1 */ /* USER CODE END ADC3_MspInit 1 */ } }