/** * @brief UART MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - DMA configuration for transmission request by peripheral * - NVIC configuration for DMA interrupt request enable * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { static DMA_HandleTypeDef hdma_tx; static DMA_HandleTypeDef hdma_rx; GPIO_InitTypeDef GPIO_InitStruct; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ USARTx_TX_GPIO_CLK_ENABLE(); USARTx_RX_GPIO_CLK_ENABLE(); /* Enable USART2 clock */ USARTx_CLK_ENABLE(); /* Enable DMA1 clock */ DMAx_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_TX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = USARTx_TX_AF; HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_RX_PIN; GPIO_InitStruct.Alternate = USARTx_RX_AF; HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the DMA streams ##########################################*/ /* Configure the DMA handler for Transmission process */ hdma_tx.Instance = USARTx_TX_DMA_STREAM; hdma_tx.Init.Channel = USARTx_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.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 the UART handle */ __HAL_LINKDMA(huart, hdmatx, hdma_tx); /* Configure the DMA handler for Transmission process */ hdma_rx.Instance = USARTx_RX_DMA_STREAM; hdma_rx.Init.Channel = USARTx_RX_DMA_CHANNEL; 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 the UART handle */ __HAL_LINKDMA(huart, hdmarx, hdma_rx); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt (USARTx_TX) */ HAL_NVIC_SetPriority(USARTx_DMA_TX_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USARTx_DMA_TX_IRQn); /* NVIC configuration for DMA transfer complete interrupt (USARTx_RX) */ HAL_NVIC_SetPriority(USARTx_DMA_RX_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USARTx_DMA_RX_IRQn); /* NVIC configuration for USART TC interrupt */ HAL_NVIC_SetPriority(USARTx_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USARTx_IRQn); }
void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc) { GPIO_InitTypeDef GPIO_InitStruct; if (hadc->Instance == BSP_ADC) { DMA_HandleTypeDef *pDmaHandle = &(gBspAdcData.dmaHandle); /* ADC clock enable */ __BSP_ADC_CLK_ENABLE(); /* DMA controller clock enable */ __BSP_DMA_CLK_ENABLE(); /* ADC1 GPIO Configuration */ GPIO_InitStruct.Pin = BSP_THERM_BED1_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_BED1_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_THERM_BED2_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_BED2_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_THERM_E1_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_E1_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_THERM_E2_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_E2_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_THERM_E3_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_E3_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_THERM_BED3_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_THERM_BED3_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = BSP_IR_OUT_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(BSP_IR_OUT_PORT, &GPIO_InitStruct); /* Peripheral DMA init*/ pDmaHandle->Instance = BSP_DMA; pDmaHandle->Init.Channel = BSP_DMA_CHANNEL; pDmaHandle->Init.Direction = DMA_PERIPH_TO_MEMORY; pDmaHandle->Init.PeriphInc = DMA_PINC_DISABLE; pDmaHandle->Init.MemInc = DMA_MINC_ENABLE; pDmaHandle->Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; pDmaHandle->Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; pDmaHandle->Init.Mode = DMA_CIRCULAR; pDmaHandle->Init.Priority = DMA_PRIORITY_LOW; pDmaHandle->Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_DeInit(pDmaHandle); HAL_DMA_Init(pDmaHandle); __HAL_LINKDMA(hadc,DMA_Handle,gBspAdcData.dmaHandle); HAL_NVIC_SetPriority(BSP_DMA_IRQn, 7, 1); HAL_NVIC_EnableIRQ(BSP_DMA_IRQn); /* Peripheral interrupt init*/ /* Sets the priority grouping field */ HAL_NVIC_SetPriority(BSP_ADC_IRQn, 7, 0); HAL_NVIC_EnableIRQ(BSP_ADC_IRQn); } }
/** * @brief Initializes the DCMI MSP. */ static void DCMI_MspInit(void) { static DMA_HandleTypeDef hdma_eval; GPIO_InitTypeDef GPIO_Init_Structure; DCMI_HandleTypeDef *hdcmi = &hdcmi_eval; /*** Enable peripherals and GPIO clocks ***/ /* Enable DCMI clock */ __DCMI_CLK_ENABLE(); /* Enable DMA2 clock */ __DMA2_CLK_ENABLE(); /* Enable GPIO clocks */ __GPIOA_CLK_ENABLE(); __GPIOB_CLK_ENABLE(); __GPIOC_CLK_ENABLE(); __GPIOD_CLK_ENABLE(); __GPIOE_CLK_ENABLE(); /*** Configure the GPIO ***/ /* Configure DCMI GPIO as alternate function */ GPIO_Init_Structure.Pin = GPIO_PIN_4; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOA, &GPIO_Init_Structure); GPIO_Init_Structure.Pin = GPIO_PIN_7 | GPIO_PIN_8; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOB, &GPIO_Init_Structure); GPIO_Init_Structure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 |\ GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 |\ GPIO_PIN_12; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOC, &GPIO_Init_Structure); GPIO_Init_Structure.Pin = GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_6; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOD, &GPIO_Init_Structure); GPIO_Init_Structure.Pin = GPIO_PIN_6; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOE, &GPIO_Init_Structure); GPIO_Init_Structure.Pin = GPIO_PIN_6; GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOA, &GPIO_Init_Structure); /*** Configure the DMA ***/ /* Set the parameters to be configured */ hdma_eval.Init.Channel = DMA_CHANNEL_1; hdma_eval.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_eval.Init.PeriphInc = DMA_PINC_DISABLE; hdma_eval.Init.MemInc = DMA_MINC_ENABLE; hdma_eval.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdma_eval.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; hdma_eval.Init.Mode = DMA_CIRCULAR; hdma_eval.Init.Priority = DMA_PRIORITY_HIGH; hdma_eval.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_eval.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_eval.Init.MemBurst = DMA_MBURST_SINGLE; hdma_eval.Init.PeriphBurst = DMA_PBURST_SINGLE; hdma_eval.Instance = DMA2_Stream1; /* Associate the initialized DMA handle to the DCMI handle */ __HAL_LINKDMA(hdcmi, DMA_Handle, hdma_eval); /*** Configure the NVIC for DCMI and DMA ***/ /* NVIC configuration for DCMI transfer complete interrupt */ HAL_NVIC_SetPriority(DCMI_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DCMI_IRQn); /* NVIC configuration for DMA2D transfer complete interrupt */ HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn); /* Configure the DMA stream */ HAL_DMA_Init(hdcmi->DMA_Handle); }
/** * @brief ADC MSP initialization * This function configures the hardware resources used in this example: * - Enable clock of ADC peripheral * - Configure the GPIO associated to the peripheral channels * - Configure the DMA associated to the peripheral * - Configure the NVIC associated to the peripheral interruptions * @param hadc: ADC handle pointer * @retval None */ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) { GPIO_InitTypeDef GPIO_InitStruct; static DMA_HandleTypeDef DmaHandle; RCC_PeriphCLKInitTypeDef PeriphClkInit; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable clock of GPIO associated to the peripheral channels */ ADCx_CHANNELa_GPIO_CLK_ENABLE(); /* Enable clock of ADCx peripheral */ ADCx_CLK_ENABLE(); /* Configure ADCx clock prescaler */ /* Caution: On STM32F1, ADC clock frequency max is 14MHz (refer to device */ /* datasheet). */ /* Therefore, ADC clock prescaler must be configured in function */ /* of ADC clock source frequency to remain below this maximum */ /* frequency. */ PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC; PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6; HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit); /* Enable clock of DMA associated to the peripheral */ ADCx_DMA_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* Configure GPIO pin of the selected ADC channel */ GPIO_InitStruct.Pin = ADCx_CHANNELa_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(ADCx_CHANNELa_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the DMA ##################################################*/ /* Configure DMA parameters */ DmaHandle.Instance = ADCx_DMA; DmaHandle.Init.Direction = DMA_MEMORY_TO_PERIPH; DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE; DmaHandle.Init.MemInc = DMA_MINC_DISABLE; DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; DmaHandle.Init.Mode = DMA_CIRCULAR; DmaHandle.Init.Priority = DMA_PRIORITY_HIGH; /* Deinitialize & Initialize the DMA for new transfer */ HAL_DMA_DeInit(&DmaHandle); HAL_DMA_Init(&DmaHandle); /* Associate the initialized DMA handle to the ADC handle */ __HAL_LINKDMA(hadc, DMA_Handle, DmaHandle); /*##-4- Configure the NVIC #################################################*/ /* NVIC configuration for DMA interrupt (transfer completion or error) */ /* Priority: high-priority */ HAL_NVIC_SetPriority(ADCx_DMA_IRQn, 1, 0); HAL_NVIC_EnableIRQ(ADCx_DMA_IRQn); /* NVIC configuration for ADC interrupt */ /* Priority: high-priority */ HAL_NVIC_SetPriority(ADCx_IRQn, 0, 0); HAL_NVIC_EnableIRQ(ADCx_IRQn); }
/** * @brief SAI MSP Init. * @param hsai : pointer to a SAI_HandleTypeDef structure that contains * the configuration information for SAI module. * @retval None */ void HAL_SAI_MspInit(SAI_HandleTypeDef *hsai) { GPIO_InitTypeDef GPIO_Init; /* Enable SAI2 clock */ AUDIO_SAIx_CLK_ENABLE(); /* Configure GPIOs used for SAI2 */ AUDIO_SAIx_MCLK_ENABLE(); AUDIO_SAIx_SCK_SD_ENABLE(); AUDIO_SAIx_FS_ENABLE(); /* CODEC_SAI pins configuration: FS, SCK, MCK and SD pins ------------------*/ GPIO_Init.Pin = AUDIO_SAIx_FS_PIN; GPIO_Init.Mode = GPIO_MODE_AF_PP; GPIO_Init.Pull = GPIO_NOPULL; GPIO_Init.Speed = GPIO_SPEED_HIGH; GPIO_Init.Alternate = AUDIO_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_SAIx_FS_GPIO_PORT, &GPIO_Init); GPIO_Init.Pin = AUDIO_SAIx_SCK_PIN; GPIO_Init.Mode = GPIO_MODE_AF_PP; GPIO_Init.Pull = GPIO_NOPULL; GPIO_Init.Speed = GPIO_SPEED_HIGH; GPIO_Init.Alternate = AUDIO_SAIx_SCK_AF; HAL_GPIO_Init(AUDIO_SAIx_SCK_SD_GPIO_PORT, &GPIO_Init); GPIO_Init.Pin = AUDIO_SAIx_SD_PIN; GPIO_Init.Mode = GPIO_MODE_AF_PP; GPIO_Init.Pull = GPIO_NOPULL; GPIO_Init.Speed = GPIO_SPEED_HIGH; GPIO_Init.Alternate = AUDIO_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_SAIx_SCK_SD_GPIO_PORT, &GPIO_Init); GPIO_Init.Pin = AUDIO_SAIx_MCLK_PIN; GPIO_Init.Mode = GPIO_MODE_AF_PP; GPIO_Init.Pull = GPIO_NOPULL; GPIO_Init.Speed = GPIO_SPEED_HIGH; GPIO_Init.Alternate = AUDIO_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_SAIx_MCLK_GPIO_PORT, &GPIO_Init); /* Configure DMA used for SAI2 */ __HAL_RCC_DMA2_CLK_ENABLE(); if(hsai->Instance == AUDIO_SAIx) { hSaiDma.Init.Channel = DMA_CHANNEL_3; hSaiDma.Init.Direction = DMA_MEMORY_TO_PERIPH; hSaiDma.Init.PeriphInc = DMA_PINC_DISABLE; hSaiDma.Init.MemInc = DMA_MINC_ENABLE; hSaiDma.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hSaiDma.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hSaiDma.Init.Mode = DMA_CIRCULAR; hSaiDma.Init.Priority = DMA_PRIORITY_HIGH; hSaiDma.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hSaiDma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hSaiDma.Init.MemBurst = DMA_MBURST_SINGLE; hSaiDma.Init.PeriphBurst = DMA_PBURST_SINGLE; /* Select the DMA instance to be used for the transfer : DMA2_Stream6 */ hSaiDma.Instance = DMA2_Stream6; /* Associate the DMA handle */ __HAL_LINKDMA(hsai, hdmatx, hSaiDma); /* Deinitialize the Stream for new transfer */ HAL_DMA_DeInit(&hSaiDma); /* Configure the DMA Stream */ if (HAL_OK != HAL_DMA_Init(&hSaiDma)) { Error_Handler(); } } HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0x01, 0); HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn); }
void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle) { GPIO_InitTypeDef GPIO_InitStruct; if(spiHandle->Instance==SPI1) { /* USER CODE BEGIN SPI1_MspInit 0 */ /* USER CODE END SPI1_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI1_CLK_ENABLE(); /**SPI1 GPIO Configuration PA5 ------> SPI1_SCK PA6 ------> SPI1_MISO PA7 ------> SPI1_MOSI */ GPIO_InitStruct.Pin = AFE_SCLK_Pin|AFE_DOUT_Pin|AFE_DIN_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_spi1_tx.Instance = DMA1_Channel3; hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_spi1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_spi1_tx.Init.MemInc = DMA_MINC_DISABLE; hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_spi1_tx.Init.Mode = DMA_NORMAL; hdma_spi1_tx.Init.Priority = DMA_PRIORITY_HIGH; if (HAL_DMA_Init(&hdma_spi1_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi1_tx); hdma_spi1_rx.Instance = DMA1_Channel2; hdma_spi1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_spi1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_spi1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_spi1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_spi1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_spi1_rx.Init.Mode = DMA_NORMAL; hdma_spi1_rx.Init.Priority = DMA_PRIORITY_HIGH; if (HAL_DMA_Init(&hdma_spi1_rx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(spiHandle,hdmarx,hdma_spi1_rx); /* USER CODE BEGIN SPI1_MspInit 1 */ /* USER CODE END SPI1_MspInit 1 */ } else if(spiHandle->Instance==SPI2) { /* USER CODE BEGIN SPI2_MspInit 0 */ /* USER CODE END SPI2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_SPI2_CLK_ENABLE(); /**SPI2 GPIO Configuration PB13 ------> SPI2_SCK PB14 ------> SPI2_MISO PB15 ------> SPI2_MOSI */ GPIO_InitStruct.Pin = TP_SCLK_Pin|TP_MISO_Pin|TP_MOSI_Pin; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF5_SPI2; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USER CODE BEGIN SPI2_MspInit 1 */ /* USER CODE END SPI2_MspInit 1 */ } }
void adcInit(drv_adc_config_t *init) { uint8_t i; uint8_t configuredAdcChannels = 0; memset(&adcConfig, 0, sizeof(adcConfig)); GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Alternate = 0xFF; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; #ifdef VBAT_ADC_GPIO if (init->enableVBat) { GPIO_InitStruct.Pin = VBAT_ADC_GPIO_PIN; HAL_GPIO_Init(VBAT_ADC_GPIO, &GPIO_InitStruct); adcConfig[ADC_BATTERY].adcChannel = VBAT_ADC_CHANNEL; adcConfig[ADC_BATTERY].dmaIndex = configuredAdcChannels++; adcConfig[ADC_BATTERY].enabled = true; adcConfig[ADC_BATTERY].sampleTime = ADC_SAMPLETIME_480CYCLES; } #endif #ifdef EXTERNAL1_ADC_GPIO if (init->enableExternal1) { GPIO_InitStruct.Pin = EXTERNAL1_ADC_GPIO_PIN; HAL_GPIO_Init(EXTERNAL1_ADC_GPIO, &GPIO_InitStruct); adcConfig[ADC_EXTERNAL1].adcChannel = EXTERNAL1_ADC_CHANNEL; adcConfig[ADC_EXTERNAL1].dmaIndex = configuredAdcChannels++; adcConfig[ADC_EXTERNAL1].enabled = true; adcConfig[ADC_EXTERNAL1].sampleTime = ADC_SAMPLETIME_480CYCLES; } #endif #ifdef RSSI_ADC_GPIO if (init->enableRSSI) { GPIO_InitStruct.Pin = RSSI_ADC_GPIO_PIN; HAL_GPIO_Init(RSSI_ADC_GPIO, &GPIO_InitStruct); adcConfig[ADC_RSSI].adcChannel = RSSI_ADC_CHANNEL; adcConfig[ADC_RSSI].dmaIndex = configuredAdcChannels++; adcConfig[ADC_RSSI].enabled = true; adcConfig[ADC_RSSI].sampleTime = ADC_SAMPLETIME_480CYCLES; } #endif #ifdef CURRENT_METER_ADC_GPIO if (init->enableCurrentMeter) { GPIO_InitStruct.Pin = CURRENT_METER_ADC_GPIO_PIN; HAL_GPIO_Init(CURRENT_METER_ADC_GPIO, &GPIO_InitStruct); adcConfig[ADC_CURRENT].adcChannel = CURRENT_METER_ADC_CHANNEL; adcConfig[ADC_CURRENT].dmaIndex = configuredAdcChannels++; adcConfig[ADC_CURRENT].enabled = true; adcConfig[ADC_CURRENT].sampleTime = ADC_SAMPLETIME_480CYCLES; } #endif __HAL_RCC_DMA2_CLK_ENABLE(); __HAL_RCC_ADC1_CLK_ENABLE(); AdcHandle_1.Instance = ADC1; AdcHandle_1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV8; AdcHandle_1.Init.Resolution = ADC_RESOLUTION_12B; AdcHandle_1.Init.ScanConvMode = configuredAdcChannels > 1 ? ENABLE : DISABLE; AdcHandle_1.Init.ContinuousConvMode = ENABLE; AdcHandle_1.Init.DiscontinuousConvMode = DISABLE; AdcHandle_1.Init.NbrOfDiscConversion = 0; AdcHandle_1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Conversion start trigged at each external event */ AdcHandle_1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1; AdcHandle_1.Init.DataAlign = ADC_DATAALIGN_RIGHT; AdcHandle_1.Init.NbrOfConversion = configuredAdcChannels; AdcHandle_1.Init.DMAContinuousRequests = ENABLE; AdcHandle_1.Init.EOCSelection = DISABLE; HAL_ADC_Init(&AdcHandle_1); hdma_adc_1.Instance = MCU_ADC1_DMA_STREAM; hdma_adc_1.Init.Channel = MCU_ADC1_DMA_CHANNEL; hdma_adc_1.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_adc_1.Init.PeriphInc = DMA_PINC_DISABLE; hdma_adc_1.Init.MemInc = configuredAdcChannels > 1 ? DMA_MINC_ENABLE : DMA_MINC_DISABLE;; hdma_adc_1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_adc_1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc_1.Init.Mode = DMA_CIRCULAR; hdma_adc_1.Init.Priority = DMA_PRIORITY_HIGH; hdma_adc_1.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_adc_1.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdma_adc_1.Init.MemBurst = DMA_MBURST_SINGLE; hdma_adc_1.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_adc_1); /* Associate the initialized DMA handle to the ADC handle */ __HAL_LINKDMA(&AdcHandle_1, DMA_Handle, hdma_adc_1); /* NVIC configuration for DMA transfer complete interrupt */ // HAL_NVIC_SetPriority(MCU_ADC1_DMA_STREAM_IRQn, NVIC_PRIORITY_BASE(NVIC_PRIO_ADC1_DMA), NVIC_PRIORITY_SUB(NVIC_PRIO_ADC1_DMA)); // HAL_NVIC_EnableIRQ(MCU_ADC1_DMA_STREAM_IRQn); uint8_t rank = 1; for (i = 0; i < ADC_CHANNEL_COUNT; i++) { if (!adcConfig[i].enabled) { continue; } ADC_ChannelConfTypeDef sConfig; sConfig.Channel = adcConfig[i].adcChannel; sConfig.Rank = rank++; sConfig.SamplingTime = adcConfig[i].sampleTime; sConfig.Offset = 0; HAL_ADC_ConfigChannel(&AdcHandle_1, &sConfig); } HAL_ADC_Start_DMA(&AdcHandle_1, (uint32_t*)&adcValues, configuredAdcChannels); }
/** * @brief Initializes BSP_AUDIO_OUT MSP. * @param hsai: SAI handle * @param Params * @retval None */ __weak void BSP_AUDIO_OUT_MspInit(SAI_HandleTypeDef *hsai, void *Params) { static DMA_HandleTypeDef hdma_sai_tx; GPIO_InitTypeDef gpio_init_structure; /* Enable SAI clock */ AUDIO_OUT_SAIx_CLK_ENABLE(); /* Enable GPIO clock */ AUDIO_OUT_SAIx_MCLK_ENABLE(); AUDIO_OUT_SAIx_SCK_SD_ENABLE(); AUDIO_OUT_SAIx_FS_ENABLE(); /* CODEC_SAI pins configuration: FS, SCK, MCK and SD pins ------------------*/ gpio_init_structure.Pin = AUDIO_OUT_SAIx_FS_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_NOPULL; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = AUDIO_OUT_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_OUT_SAIx_FS_GPIO_PORT, &gpio_init_structure); gpio_init_structure.Pin = AUDIO_OUT_SAIx_SCK_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_NOPULL; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = AUDIO_OUT_SAIx_SCK_AF; HAL_GPIO_Init(AUDIO_OUT_SAIx_SCK_SD_GPIO_PORT, &gpio_init_structure); gpio_init_structure.Pin = AUDIO_OUT_SAIx_SD_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_NOPULL; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = AUDIO_OUT_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_OUT_SAIx_SCK_SD_GPIO_PORT, &gpio_init_structure); gpio_init_structure.Pin = AUDIO_OUT_SAIx_MCLK_PIN; gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_NOPULL; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = AUDIO_OUT_SAIx_FS_SD_MCLK_AF; HAL_GPIO_Init(AUDIO_OUT_SAIx_MCLK_GPIO_PORT, &gpio_init_structure); /* Enable the DMA clock */ AUDIO_OUT_SAIx_DMAx_CLK_ENABLE(); if(hsai->Instance == AUDIO_OUT_SAIx) { /* Configure the hdma_saiTx handle parameters */ hdma_sai_tx.Init.Channel = AUDIO_OUT_SAIx_DMAx_CHANNEL; hdma_sai_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_sai_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_sai_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_sai_tx.Init.PeriphDataAlignment = AUDIO_OUT_SAIx_DMAx_PERIPH_DATA_SIZE; hdma_sai_tx.Init.MemDataAlignment = AUDIO_OUT_SAIx_DMAx_MEM_DATA_SIZE; hdma_sai_tx.Init.Mode = DMA_CIRCULAR; hdma_sai_tx.Init.Priority = DMA_PRIORITY_HIGH; hdma_sai_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_sai_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_sai_tx.Init.MemBurst = DMA_MBURST_SINGLE; hdma_sai_tx.Init.PeriphBurst = DMA_PBURST_SINGLE; hdma_sai_tx.Instance = AUDIO_OUT_SAIx_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsai, hdmatx, hdma_sai_tx); /* Deinitialize the Stream for new transfer */ HAL_DMA_DeInit(&hdma_sai_tx); /* Configure the DMA Stream */ HAL_DMA_Init(&hdma_sai_tx); } /* SAI DMA IRQ Channel configuration */ HAL_NVIC_SetPriority(AUDIO_OUT_SAIx_DMAx_IRQ, AUDIO_OUT_IRQ_PREPRIO, 0); HAL_NVIC_EnableIRQ(AUDIO_OUT_SAIx_DMAx_IRQ); }
/** * @brief Initializes the SDRAM device. * @retval SDRAM status */ uint8_t stm32_sdram_init(sdram_config_t *config) { static uint8_t sdramstatus = SDRAM_ERROR; static DMA_HandleTypeDef dma_handle; /* SDRAM device configuration */ sdramHandle.Instance = FMC_SDRAM_DEVICE; /* Timing configuration for 100Mhz as SDRAM clock frequency (System clock is up to 200Mhz) */ FMC_SDRAM_TimingTypeDef Timing; Timing.LoadToActiveDelay = 2; Timing.ExitSelfRefreshDelay = 7; Timing.SelfRefreshTime = 4; Timing.RowCycleDelay = 7; Timing.WriteRecoveryTime = 2; Timing.RPDelay = 2; Timing.RCDDelay = 2; sdramHandle.Init.SDBank = FMC_SDRAM_BANK1; sdramHandle.Init.ColumnBitsNumber = GetColumnBitsNumber(config); sdramHandle.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_12; sdramHandle.Init.MemoryDataWidth = GetMemoryWidth(config); sdramHandle.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4; sdramHandle.Init.CASLatency = GetCasLatencyFMC(config); sdramHandle.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE; sdramHandle.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2; sdramHandle.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE; sdramHandle.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0; /* Enable FMC clock */ __HAL_RCC_FMC_CLK_ENABLE(); /* Enable chosen DMAx clock */ __DMAx_CLK_ENABLE(); /* SDRAM GPIO initialization */ stm_sdram_GPIO_init(); /* Configure common DMA parameters */ dma_handle.Init.Channel = SDRAM_DMAx_CHANNEL; dma_handle.Init.Direction = DMA_MEMORY_TO_MEMORY; dma_handle.Init.PeriphInc = DMA_PINC_ENABLE; dma_handle.Init.MemInc = DMA_MINC_ENABLE; dma_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_handle.Init.Mode = DMA_NORMAL; dma_handle.Init.Priority = DMA_PRIORITY_HIGH; dma_handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; dma_handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_handle.Init.MemBurst = DMA_MBURST_SINGLE; dma_handle.Init.PeriphBurst = DMA_PBURST_SINGLE; dma_handle.Instance = SDRAM_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(&sdramHandle, hdma, dma_handle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_handle); /* Configure the DMA stream */ HAL_DMA_Init(&dma_handle); #if 0 /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SDRAM_DMAx_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDRAM_DMAx_IRQn); #endif if (HAL_SDRAM_Init(&sdramHandle, &Timing) != HAL_OK) { sdramstatus = SDRAM_ERROR; } else { sdramstatus = SDRAM_OK; } /* SDRAM initialization sequence */ BSP_SDRAM_Initialization_sequence(REFRESH_COUNT, GetCasLatencyModeReg(config)); return sdramstatus; }
void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; if(huart->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* Peripheral clock enable */ __USART1_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart1_tx.Instance = DMA2_Stream7; hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4; hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_tx.Init.Mode = DMA_NORMAL; hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_usart1_tx); __HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx); hdma_usart1_rx.Instance = DMA2_Stream2; hdma_usart1_rx.Init.Channel = DMA_CHANNEL_4; hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_rx.Init.Mode = DMA_NORMAL; hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_usart1_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_usart1_rx.Init.MemBurst = DMA_MBURST_SINGLE; hdma_usart1_rx.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_usart1_rx); __HAL_LINKDMA(huart,hdmarx,hdma_usart1_rx); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(USART1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else 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_HIGH; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(USART2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } }
void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc) { GPIO_InitTypeDef GPIO_InitStruct; if(hadc->Instance==ADC_CH_1) { /* USER CODE BEGIN ADC1_MspInit 0 */ /* USER CODE END ADC1_MspInit 0 */ /* Peripheral clock enable */ GPIO_ADC_CH_1_CLK_EN(); ADC_CH_1_CLK_EN(); /**ADC1 GPIO Configuration PC1 ------> ADC1_IN11 */ GPIO_InitStruct.Pin = ADC_PIN_CH_1; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_adc1.Instance = ADC_DMA_STREAM_CH_1; hdma_adc1.Init.Channel = ADC_DMA_CHANNEL_CH_1; hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE; hdma_adc1.Init.MemInc = DMA_MINC_ENABLE; if (ADCResolution==ADC_RESOLUTION8b || ADCResolution==ADC_RESOLUTION6b){ hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; }else{ hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; } hdma_adc1.Init.Mode = DMA_CIRCULAR; hdma_adc1.Init.Priority = DMA_PRIORITY_HIGH; hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_adc1.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdma_adc1.Init.MemBurst = DMA_MBURST_SINGLE; hdma_adc1.Init.PeriphBurst = DMA_PBURST_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 */ } else if(hadc->Instance==ADC_CH_2) { /* USER CODE BEGIN ADC2_MspInit 0 */ /* USER CODE END ADC2_MspInit 0 */ /* Peripheral clock enable */ GPIO_ADC_CH_2_CLK_EN(); ADC_CH_2_CLK_EN(); /**ADC2 GPIO Configuration PC2 ------> ADC2_IN12 */ GPIO_InitStruct.Pin = ADC_PIN_CH_2; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_adc2.Instance = ADC_DMA_STREAM_CH_2; hdma_adc2.Init.Channel = ADC_DMA_CHANNEL_CH_2; hdma_adc2.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_adc2.Init.PeriphInc = DMA_PINC_DISABLE; hdma_adc2.Init.MemInc = DMA_MINC_ENABLE; if (ADCResolution==ADC_RESOLUTION8b || ADCResolution==ADC_RESOLUTION6b){ hdma_adc2.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_adc2.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; }else{ hdma_adc2.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc2.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; } hdma_adc2.Init.Mode = DMA_CIRCULAR; hdma_adc2.Init.Priority = DMA_PRIORITY_HIGH; hdma_adc2.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_adc2.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdma_adc2.Init.MemBurst = DMA_MBURST_SINGLE; hdma_adc2.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_adc2); __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc2); /* USER CODE BEGIN ADC2_MspInit 1 */ /* USER CODE END ADC2_MspInit 1 */ } else if(hadc->Instance==ADC_CH_3) { /* USER CODE BEGIN ADC3_MspInit 0 */ /* USER CODE END ADC3_MspInit 0 */ /* Peripheral clock enable */ GPIO_ADC_CH_3_CLK_EN(); ADC_CH_3_CLK_EN(); /**ADC3 GPIO Configuration PC3 ------> ADC3_IN13 */ GPIO_InitStruct.Pin = ADC_PIN_CH_3; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_adc3.Instance = ADC_DMA_STREAM_CH_3; hdma_adc3.Init.Channel = ADC_DMA_CHANNEL_CH_3; hdma_adc3.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_adc3.Init.PeriphInc = DMA_PINC_DISABLE; hdma_adc3.Init.MemInc = DMA_MINC_ENABLE; if (ADCResolution==ADC_RESOLUTION8b || ADCResolution==ADC_RESOLUTION6b){ hdma_adc3.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_adc3.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; }else{ hdma_adc3.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_adc3.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; } hdma_adc3.Init.Mode = DMA_CIRCULAR; hdma_adc3.Init.Priority = DMA_PRIORITY_HIGH; hdma_adc3.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_adc3.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdma_adc3.Init.MemBurst = DMA_MBURST_SINGLE; hdma_adc3.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_adc3); __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc3); /* USER CODE BEGIN ADC3_MspInit 1 */ /* USER CODE END ADC3_MspInit 1 */ } }
/** * @brief AUDIO IN I2S MSP Init * @param hi2s: I2S handle * @retval None */ static void I2S2_MspInit(void) { static DMA_HandleTypeDef hdma_i2sRx; GPIO_InitTypeDef GPIO_InitStruct; I2S_HandleTypeDef *hi2s = &hAudioInI2s; /* Enable the I2S2 peripheral clock */ I2S2_CLK_ENABLE(); /* Enable I2S GPIO clocks */ I2S2_SCK_GPIO_CLK_ENABLE(); I2S2_MOSI_GPIO_CLK_ENABLE(); /* I2S2 pins configuration: SCK and MOSI pins ------------------------------*/ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Pin = I2S2_SCK_PIN; GPIO_InitStruct.Alternate = I2S2_SCK_AF; HAL_GPIO_Init(I2S2_SCK_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = I2S2_MOSI_PIN ; GPIO_InitStruct.Alternate = I2S2_MOSI_AF; HAL_GPIO_Init(I2S2_MOSI_GPIO_PORT, &GPIO_InitStruct); /* Enable the DMA clock */ I2S2_DMAx_CLK_ENABLE(); if(hi2s->Instance == I2S2) { /* Configure the hdma_i2sRx handle parameters */ hdma_i2sRx.Init.Channel = I2S2_DMAx_CHANNEL; hdma_i2sRx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2sRx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2sRx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2sRx.Init.PeriphDataAlignment = I2S2_DMAx_PERIPH_DATA_SIZE; hdma_i2sRx.Init.MemDataAlignment = I2S2_DMAx_MEM_DATA_SIZE; hdma_i2sRx.Init.Mode = DMA_CIRCULAR; hdma_i2sRx.Init.Priority = DMA_PRIORITY_HIGH; hdma_i2sRx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; hdma_i2sRx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_i2sRx.Init.MemBurst = DMA_MBURST_SINGLE; hdma_i2sRx.Init.PeriphBurst = DMA_MBURST_SINGLE; hdma_i2sRx.Instance = I2S2_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hi2s, hdmarx, hdma_i2sRx); /* Deinitialize the Stream for new transfer */ HAL_DMA_DeInit(&hdma_i2sRx); /* Configure the DMA Stream */ HAL_DMA_Init(&hdma_i2sRx); } /* I2S DMA IRQ Channel configuration */ HAL_NVIC_SetPriority(I2S2_DMAx_IRQ, AUDIO_IN_IRQ_PREPRIO, 0); HAL_NVIC_EnableIRQ(I2S2_DMAx_IRQ); }
/** * @brief Initializes the SD card device. * @param None * @retval SD status */ uint8_t BSP_SD_Init(void) { uint8_t SD_state = MSD_OK; /* uSD device interface configuration */ #if defined(SDIO) uSdHandle.Instance = SDIO; uSdHandle.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING; uSdHandle.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE; uSdHandle.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE; uSdHandle.Init.BusWide = SDIO_BUS_WIDE_1B; uSdHandle.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE; uSdHandle.Init.ClockDiv = SDIO_TRANSFER_CLK_DIV; #elif defined(SDMMC1) uSdHandle.Instance = SDMMC1; uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING; uSdHandle.Init.ClockBypass = SDMMC_CLOCK_BYPASS_DISABLE; uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE; uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_1B; uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE; uSdHandle.Init.ClockDiv = SDMMC_TRANSFER_CLK_DIV; #else #error "NOT SUPPORTED!" #endif /* Init GPIO, DMA and NVIC */ SD_MspInit(); /* Check if the SD card is plugged in the slot */ if (BSP_SD_IsDetected() != SD_PRESENT) { return MSD_ERROR; } /* HAL SD initialization */ if (HAL_SD_Init(&uSdHandle, &uSdCardInfo) != SD_OK) { SD_state = MSD_ERROR; } /* Configure SD Bus width */ if (SD_state == MSD_OK) { /* Enable wide operation */ #if defined(SDIO_BUS_WIDE_4B) #if FATFS_SDIO_4BIT == 1 if (HAL_SD_WideBusOperation_Config(&uSdHandle, SDIO_BUS_WIDE_4B) != SD_OK) { #else if (HAL_SD_WideBusOperation_Config(&uSdHandle, SDIO_BUS_WIDE_1B) != SD_OK) { #endif #else #if FATFS_SDIO_4BIT == 1 if (HAL_SD_WideBusOperation_Config(&uSdHandle, SDMMC_BUS_WIDE_4B) != SD_OK) { #else if (HAL_SD_WideBusOperation_Config(&uSdHandle, SDMMC_BUS_WIDE_1B) != SD_OK) { #endif #endif SD_state = MSD_ERROR; } else { SD_state = MSD_OK; } } return SD_state; } /** * @brief Detects if SD card is correctly plugged in the memory slot or not. * @param None * @retval Returns if SD is detected or not */ uint8_t BSP_SD_IsDetected(void) { return SDCARD_IsDetected(); } /** * @brief Detects if SD card is write protected * @param None * @retval Returns if SD is write protected or not. */ uint8_t BSP_SD_IsWriteProtected(void) { return !SDCARD_IsWriteEnabled(); } /** * @brief Reads block(s) from a specified address in an SD card, in polling mode. * @param pData: Pointer to the buffer that will contain the data to transmit * @param ReadAddr: Address from where data is to be read * @param BlockSize: SD card data block size, that should be 512 * @param NumOfBlocks: Number of SD blocks to read * @retval SD status */ uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumOfBlocks) { if (HAL_SD_ReadBlocks(&uSdHandle, pData, ReadAddr, BlockSize, NumOfBlocks) != SD_OK) { return MSD_ERROR; } return MSD_OK; } /** * @brief Writes block(s) to a specified address in an SD card, in polling mode. * @param pData: Pointer to the buffer that will contain the data to transmit * @param WriteAddr: Address from where data is to be written * @param BlockSize: SD card data block size, that should be 512 * @param NumOfBlocks: Number of SD blocks to write * @retval SD status */ uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumOfBlocks) { if (HAL_SD_WriteBlocks(&uSdHandle, pData, WriteAddr, BlockSize, NumOfBlocks) != SD_OK) { return MSD_ERROR; } return MSD_OK; } /** * @brief Reads block(s) from a specified address in an SD card, in DMA mode. * @param pData: Pointer to the buffer that will contain the data to transmit * @param ReadAddr: Address from where data is to be read * @param BlockSize: SD card data block size, that should be 512 * @param NumOfBlocks: Number of SD blocks to read * @retval SD status */ uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumOfBlocks) { uint8_t SD_state = MSD_OK; /* Read block(s) in DMA transfer mode */ if (HAL_SD_ReadBlocks_DMA(&uSdHandle, pData, ReadAddr, BlockSize, NumOfBlocks) != SD_OK) { SD_state = MSD_ERROR; } /* Wait until transfer is complete */ if (SD_state == MSD_OK) { if (HAL_SD_CheckReadOperation(&uSdHandle, (uint32_t)SD_DATATIMEOUT) != SD_OK) { SD_state = MSD_ERROR; } else { SD_state = MSD_OK; } } return SD_state; } /** * @brief Writes block(s) to a specified address in an SD card, in DMA mode. * @param pData: Pointer to the buffer that will contain the data to transmit * @param WriteAddr: Address from where data is to be written * @param BlockSize: SD card data block size, that should be 512 * @param NumOfBlocks: Number of SD blocks to write * @retval SD status */ uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumOfBlocks) { uint8_t SD_state = MSD_OK; /* Write block(s) in DMA transfer mode */ if (HAL_SD_WriteBlocks_DMA(&uSdHandle, pData, WriteAddr, BlockSize, NumOfBlocks) != SD_OK) { SD_state = MSD_ERROR; } /* Wait until transfer is complete */ if (SD_state == MSD_OK) { if(HAL_SD_CheckWriteOperation(&uSdHandle, (uint32_t)SD_DATATIMEOUT) != SD_OK) { SD_state = MSD_ERROR; } else { SD_state = MSD_OK; } } return SD_state; } /** * @brief Erases the specified memory area of the given SD card. * @param StartAddr: Start byte address * @param EndAddr: End byte address * @retval SD status */ uint8_t BSP_SD_Erase(uint64_t StartAddr, uint64_t EndAddr) { if (HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) != SD_OK) { return MSD_ERROR; } return MSD_OK; } /** * @brief Initializes the SD MSP. * @param None * @retval None */ static void SD_MspInit(void) { static DMA_HandleTypeDef dmaRxHandle; static DMA_HandleTypeDef dmaTxHandle; SD_HandleTypeDef *hsd = &uSdHandle; uint16_t gpio_af; /* Get GPIO alternate function */ #if defined(GPIO_AF12_SDIO) gpio_af = GPIO_AF12_SDIO; #endif #if defined(GPIO_AF12_SDMMC1) gpio_af = GPIO_AF12_SDMMC1; #endif /* Enable SDIO clock */ __HAL_RCC_SDIO_CLK_ENABLE(); /* Enable DMA2 clocks */ __DMAx_TxRx_CLK_ENABLE(); /* Detect pin, write protect pin */ #if FATFS_USE_DETECT_PIN > 0 TM_GPIO_Init(FATFS_DETECT_PORT, FATFS_DETECT_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Low); #endif #if FATFS_USE_WRITEPROTECT_PIN > 0 TM_GPIO_Init(FATFS_WRITEPROTECT_PORT, FATFS_WRITEPROTECT_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Low); #endif /* SDIO/SDMMC pins */ #if FATFS_SDIO_4BIT == 1 TM_GPIO_InitAlternate(GPIOC, GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Fast, gpio_af); #else TM_GPIO_InitAlternate(GPIOC, GPIO_PIN_8 | GPIO_PIN_12, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Fast, gpio_af); #endif TM_GPIO_InitAlternate(GPIOD, GPIO_PIN_2, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Fast, gpio_af); /* NVIC configuration for SDIO interrupts */ HAL_NVIC_SetPriority(SDIO_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDIO_IRQn); /* Configure DMA Rx parameters */ dmaRxHandle.Init.Channel = SD_DMAx_Rx_CHANNEL; dmaRxHandle.Init.Direction = DMA_PERIPH_TO_MEMORY; dmaRxHandle.Init.PeriphInc = DMA_PINC_DISABLE; dmaRxHandle.Init.MemInc = DMA_MINC_ENABLE; dmaRxHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dmaRxHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dmaRxHandle.Init.Mode = DMA_PFCTRL; dmaRxHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dmaRxHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dmaRxHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dmaRxHandle.Init.MemBurst = DMA_MBURST_INC4; dmaRxHandle.Init.PeriphBurst = DMA_PBURST_INC4; dmaRxHandle.Instance = SD_DMAx_Rx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmarx, dmaRxHandle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dmaRxHandle); /* Configure the DMA stream */ HAL_DMA_Init(&dmaRxHandle); /* Configure DMA Tx parameters */ dmaTxHandle.Init.Channel = SD_DMAx_Tx_CHANNEL; dmaTxHandle.Init.Direction = DMA_MEMORY_TO_PERIPH; dmaTxHandle.Init.PeriphInc = DMA_PINC_DISABLE; dmaTxHandle.Init.MemInc = DMA_MINC_ENABLE; dmaTxHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dmaTxHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dmaTxHandle.Init.Mode = DMA_PFCTRL; dmaTxHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dmaTxHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dmaTxHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dmaTxHandle.Init.MemBurst = DMA_MBURST_INC4; dmaTxHandle.Init.PeriphBurst = DMA_PBURST_INC4; dmaTxHandle.Instance = SD_DMAx_Tx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmatx, dmaTxHandle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dmaTxHandle); /* Configure the DMA stream */ HAL_DMA_Init(&dmaTxHandle); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD_DMAx_Rx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD_DMAx_Rx_IRQn); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD_DMAx_Tx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD_DMAx_Tx_IRQn); } /** * @brief Get SD information about specific SD card. * @param CardInfo: Pointer to HAL_SD_CardInfoTypedef structure * @retval None */ void BSP_SD_GetCardInfo(HAL_SD_CardInfoTypedef *CardInfo) { /* Get SD card Information */ HAL_SD_Get_CardInfo(&uSdHandle, CardInfo); }
/** * @brief SPI MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - DMA configuration for transmission request by peripheral * - NVIC configuration for DMA interrupt request enable * @param hspi: SPI handle pointer * @retval None */ void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) { GPIO_InitTypeDef GPIO_InitStruct; if (hspi->Instance == SPIx) { /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ SPIx_SCK_GPIO_CLK_ENABLE(); SPIx_MISO_GPIO_CLK_ENABLE(); SPIx_MOSI_GPIO_CLK_ENABLE(); /* Enable SPI2 clock */ SPIx_CLK_ENABLE(); /* Enable DMA clock */ DMAx_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* SPI SCK GPIO pin configuration */ GPIO_InitStruct.Pin = SPIx_SCK_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLDOWN; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = SPIx_SCK_AF; HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct); /* SPI MISO GPIO pin configuration */ GPIO_InitStruct.Pin = SPIx_MISO_PIN; GPIO_InitStruct.Alternate = SPIx_MISO_AF; HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct); /* SPI MOSI GPIO pin configuration */ GPIO_InitStruct.Pin = SPIx_MOSI_PIN; GPIO_InitStruct.Alternate = SPIx_MOSI_AF; HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the DMA ##################################################*/ /* Configure the DMA handler for Transmission process */ hdma_tx.Instance = SPIx_TX_DMA_STREAM; hdma_tx.Init.Channel = SPIx_TX_DMA_CHANNEL; 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; 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; HAL_DMA_Init(&hdma_tx); /* Associate the initialized DMA handle to the the SPI handle */ __HAL_LINKDMA(hspi, hdmatx, hdma_tx); /* Configure the DMA handler for Transmission process */ hdma_rx.Instance = SPIx_RX_DMA_STREAM; hdma_rx.Init.Channel = SPIx_RX_DMA_CHANNEL; 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; 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; HAL_DMA_Init(&hdma_rx); /* Associate the initialized DMA handle to the the SPI handle */ __HAL_LINKDMA(hspi, hdmarx, hdma_rx); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt (SPI2_TX) */ HAL_NVIC_SetPriority(SPIx_DMA_TX_IRQn, 1, 1); HAL_NVIC_EnableIRQ(SPIx_DMA_TX_IRQn); /* NVIC configuration for DMA transfer complete interrupt (SPI2_RX) */ HAL_NVIC_SetPriority(SPIx_DMA_RX_IRQn, 1, 0); HAL_NVIC_EnableIRQ(SPIx_DMA_RX_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 PA7 ------> ADC1_IN7 PC4 ------> ADC1_IN14 PC5 ------> ADC1_IN15 */ GPIO_InitStruct.Pin = GYRO_TEMP_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GYRO_TEMP_GPIO_Port, &GPIO_InitStruct); GPIO_InitStruct.Pin = GYRO_RATE_Pin | VBAT_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_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, 4); HAL_NVIC_EnableIRQ(ADC_IRQn); /* USER CODE BEGIN ADC1_MspInit 1 */ /* USER CODE END ADC1_MspInit 1 */ } else if (hadc->Instance == ADC2) { /* USER CODE BEGIN ADC2_MspInit 0 */ /* USER CODE END ADC2_MspInit 0 */ /* Peripheral clock enable */ __ADC2_CLK_ENABLE() ; /**ADC2 GPIO Configuration PC0 ------> ADC2_IN10 PC1 ------> ADC2_IN11 PC3 ------> ADC2_IN13 PA4 ------> ADC2_IN4 PA5 ------> ADC2_IN5 PA6 ------> ADC2_IN6 */ GPIO_InitStruct.Pin = GPIO_PIN_0 | R_FRONT_RX_Pin | LINE_SENSOR_R1_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = LINE_SENSOR_L1_Pin | L_DIAG_RX_Pin | L_FRONT_RX_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(ADC_IRQn, 0, 4); HAL_NVIC_EnableIRQ(ADC_IRQn); /* USER CODE BEGIN ADC2_MspInit 1 */ /* USER CODE END ADC2_MspInit 1 */ } else if (hadc->Instance == ADC3) { /* USER CODE BEGIN ADC3_MspInit 0 */ /* USER CODE END ADC3_MspInit 0 */ /* Peripheral clock enable */ __ADC3_CLK_ENABLE() ; /**ADC3 GPIO Configuration PC0 ------> ADC3_IN10 PC2 ------> ADC3_IN12 PA1 ------> ADC3_IN1 PA3 ------> ADC3_IN3 */ GPIO_InitStruct.Pin = GPIO_PIN_0 | LINE_SENSOR_R2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = LINE_SENSOR_F_Pin | LINE_SENSOR_L2_Pin; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(ADC_IRQn, 0, 4); HAL_NVIC_EnableIRQ(ADC_IRQn); /* USER CODE BEGIN ADC3_MspInit 1 */ /* USER CODE END ADC3_MspInit 1 */ } }
void HAL_SD_MspInit(SD_HandleTypeDef* hsd) { GPIO_InitTypeDef GPIO_InitStruct; if(hsd->Instance==SDIO) { /* USER CODE BEGIN SDIO_MspInit 0 */ /* USER CODE END SDIO_MspInit 0 */ /* Peripheral clock enable */ __SDIO_CLK_ENABLE(); /**SDIO GPIO Configuration PC12 ------> SDIO_CK PC11 ------> SDIO_D3 PC10 ------> SDIO_D2 PD2 ------> SDIO_CMD PC9 ------> SDIO_D1 PC8 ------> SDIO_D0 */ GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_11|GPIO_PIN_10|GPIO_PIN_9 |GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF12_SDIO; HAL_GPIO_Init(GPIOD, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_sdio.Instance = DMA2_Stream3; hdma_sdio.Init.Channel = DMA_CHANNEL_4; hdma_sdio.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_sdio.Init.PeriphInc = DMA_PINC_DISABLE; hdma_sdio.Init.MemInc = DMA_MINC_ENABLE; hdma_sdio.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_sdio.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_sdio.Init.Mode = DMA_PFCTRL; hdma_sdio.Init.Priority = DMA_PRIORITY_LOW; hdma_sdio.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_sdio.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdma_sdio.Init.MemBurst = DMA_MBURST_SINGLE; hdma_sdio.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_sdio); /* Several peripheral DMA handle pointers point to the same DMA handle. Be aware that there is only one stream to perform all the requested DMAs. */ /* Be sure to change transfer direction before calling HAL_SD_ReadBlocks_DMA or HAL_SD_WriteBlocks_DMA. */ __HAL_LINKDMA(hsd,hdmarx,hdma_sdio); __HAL_LINKDMA(hsd,hdmatx,hdma_sdio); /* USER CODE BEGIN SDIO_MspInit 1 */ /* USER CODE END SDIO_MspInit 1 */ } }
/** * @brief Initializes SDRAM MSP. * @note This function can be surcharged by application code. * @param hsdram: pointer on SDRAM handle * @param Params: pointer on additional configuration parameters, can be NULL. */ __weak void BSP_SDRAM_MspInit(SDRAM_HandleTypeDef *hsdram, void *Params) { static DMA_HandleTypeDef dma_handle; GPIO_InitTypeDef gpio_init_structure; if(hsdram != (SDRAM_HandleTypeDef *)NULL) { /* Enable FMC clock */ __HAL_RCC_FMC_CLK_ENABLE(); /* Enable chosen DMAx clock */ __DMAx_CLK_ENABLE(); /* Enable GPIOs clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); __HAL_RCC_GPIOH_CLK_ENABLE(); __HAL_RCC_GPIOI_CLK_ENABLE(); /* Common GPIO configuration */ gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Speed = GPIO_SPEED_FAST; gpio_init_structure.Alternate = GPIO_AF12_FMC; /* GPIOC configuration : PC0 is SDNWE */ gpio_init_structure.Pin = GPIO_PIN_0; HAL_GPIO_Init(GPIOC, &gpio_init_structure); /* GPIOD configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_8| GPIO_PIN_9 | GPIO_PIN_10 |\ GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOD, &gpio_init_structure); /* GPIOE configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_7| GPIO_PIN_8 | GPIO_PIN_9 |\ GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOE, &gpio_init_structure); /* GPIOF configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |\ GPIO_PIN_5 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOF, &gpio_init_structure); /* GPIOG configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4| GPIO_PIN_5 | GPIO_PIN_8 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOG, &gpio_init_structure); /* GPIOH configuration */ gpio_init_structure.Pin = GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_8 | GPIO_PIN_9 |\ GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |\ GPIO_PIN_15; HAL_GPIO_Init(GPIOH, &gpio_init_structure); /* GPIOI configuration */ gpio_init_structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 |\ GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9 | GPIO_PIN_10; HAL_GPIO_Init(GPIOI, &gpio_init_structure); /* Configure common DMA parameters */ dma_handle.Init.Channel = SDRAM_DMAx_CHANNEL; dma_handle.Init.Direction = DMA_MEMORY_TO_MEMORY; dma_handle.Init.PeriphInc = DMA_PINC_ENABLE; dma_handle.Init.MemInc = DMA_MINC_ENABLE; dma_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_handle.Init.Mode = DMA_NORMAL; dma_handle.Init.Priority = DMA_PRIORITY_HIGH; dma_handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; dma_handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_handle.Init.MemBurst = DMA_MBURST_SINGLE; dma_handle.Init.PeriphBurst = DMA_PBURST_SINGLE; dma_handle.Instance = SDRAM_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsdram, hdma, dma_handle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_handle); /* Configure the DMA stream */ HAL_DMA_Init(&dma_handle); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SDRAM_DMAx_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDRAM_DMAx_IRQn); } /* of if(hsdram != (SDRAM_HandleTypeDef *)NULL) */ }
void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; 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_HIGH; GPIO_InitStruct.Alternate = GPIO_AF8_USART6; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart6_rx.Instance = DMA2_Stream1; hdma_usart6_rx.Init.Channel = DMA_CHANNEL_5; hdma_usart6_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart6_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart6_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart6_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart6_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart6_rx.Init.Mode = DMA_NORMAL; hdma_usart6_rx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart6_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_usart6_rx); __HAL_LINKDMA(huart,hdmarx,hdma_usart6_rx); hdma_usart6_tx.Instance = DMA2_Stream6; hdma_usart6_tx.Init.Channel = DMA_CHANNEL_5; hdma_usart6_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart6_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart6_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart6_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart6_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart6_tx.Init.Mode = DMA_NORMAL; hdma_usart6_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_usart6_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_usart6_tx); __HAL_LINKDMA(huart,hdmatx,hdma_usart6_tx); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(USART6_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART6_IRQn); /* USER CODE BEGIN USART6_MspInit 1 */ /* USER CODE END USART6_MspInit 1 */ } }
/** * @brief QSPI MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - DMA configuration for requests by peripheral * - NVIC configuration for DMA and QSPI interrupts * @param hqspi: QSPI handle pointer * @retval None */ void HAL_QSPI_MspInit(QSPI_HandleTypeDef *hqspi) { GPIO_InitTypeDef GPIO_InitStruct; static DMA_HandleTypeDef hdma; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable the QuadSPI memory interface clock */ QSPI_CLK_ENABLE(); /* Reset the QuadSPI memory interface */ QSPI_FORCE_RESET(); QSPI_RELEASE_RESET(); /* Enable GPIO clocks */ QSPI_CS_GPIO_CLK_ENABLE(); QSPI_CLK_GPIO_CLK_ENABLE(); QSPI_D0_GPIO_CLK_ENABLE(); QSPI_D1_GPIO_CLK_ENABLE(); QSPI_D2_GPIO_CLK_ENABLE(); QSPI_D3_GPIO_CLK_ENABLE(); /* Enable DMA clock */ QSPI_DMA_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* QSPI CS GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_CS_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF10_QSPI; HAL_GPIO_Init(QSPI_CS_GPIO_PORT, &GPIO_InitStruct); /* QSPI CLK GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_CLK_PIN; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Alternate = GPIO_AF9_QSPI; HAL_GPIO_Init(QSPI_CLK_GPIO_PORT, &GPIO_InitStruct); /* QSPI D0 GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_D0_PIN; GPIO_InitStruct.Alternate = GPIO_AF10_QSPI; HAL_GPIO_Init(QSPI_D0_GPIO_PORT, &GPIO_InitStruct); /* QSPI D1 GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_D1_PIN; GPIO_InitStruct.Alternate = GPIO_AF10_QSPI; HAL_GPIO_Init(QSPI_D1_GPIO_PORT, &GPIO_InitStruct); /* QSPI D2 GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_D2_PIN; GPIO_InitStruct.Alternate = GPIO_AF9_QSPI; HAL_GPIO_Init(QSPI_D2_GPIO_PORT, &GPIO_InitStruct); /* QSPI D3 GPIO pin configuration */ GPIO_InitStruct.Pin = QSPI_D3_PIN; GPIO_InitStruct.Alternate = GPIO_AF9_QSPI; HAL_GPIO_Init(QSPI_D3_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the NVIC for QSPI #########################################*/ /* NVIC configuration for QSPI interrupt */ HAL_NVIC_SetPriority(QUADSPI_IRQn, 0x0F, 0); HAL_NVIC_EnableIRQ(QUADSPI_IRQn); /*##-4- Configure the DMA channel ###########################################*/ /* QSPI DMA channel configuration */ hdma.Init.Channel = QSPI_DMA_CHANNEL; 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.Priority = DMA_PRIORITY_LOW; hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* FIFO mode disabled */ hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma.Init.MemBurst = DMA_MBURST_SINGLE; /* Memory burst */ hdma.Init.PeriphBurst = DMA_PBURST_SINGLE; /* Peripheral burst */ hdma.Instance = QSPI_DMA_INSTANCE; __HAL_LINKDMA(hqspi, hdma, hdma); HAL_DMA_Init(&hdma); /* NVIC configuration for DMA interrupt */ HAL_NVIC_SetPriority(QSPI_DMA_IRQ, 0x00, 0); HAL_NVIC_EnableIRQ(QSPI_DMA_IRQ); }
void uartReconfigure(uartPort_t *uartPort) { /*RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit; RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_USART2|RCC_PERIPHCLK_USART3| RCC_PERIPHCLK_UART4|RCC_PERIPHCLK_UART5|RCC_PERIPHCLK_USART6|RCC_PERIPHCLK_UART7|RCC_PERIPHCLK_UART8; RCC_PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Usart2ClockSelection = RCC_USART2CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Uart4ClockSelection = RCC_UART4CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Uart5ClockSelection = RCC_UART5CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Usart6ClockSelection = RCC_USART6CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Uart7ClockSelection = RCC_UART7CLKSOURCE_SYSCLK; RCC_PeriphClkInit.Uart8ClockSelection = RCC_UART8CLKSOURCE_SYSCLK; HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);*/ HAL_UART_DeInit(&uartPort->Handle); uartPort->Handle.Init.BaudRate = uartPort->port.baudRate; // according to the stm32 documentation wordlen has to be 9 for parity bits // this does not seem to matter for rx but will give bad data on tx! uartPort->Handle.Init.WordLength = (uartPort->port.options & SERIAL_PARITY_EVEN) ? UART_WORDLENGTH_9B : UART_WORDLENGTH_8B; uartPort->Handle.Init.StopBits = (uartPort->port.options & SERIAL_STOPBITS_2) ? USART_STOPBITS_2 : USART_STOPBITS_1; uartPort->Handle.Init.Parity = (uartPort->port.options & SERIAL_PARITY_EVEN) ? USART_PARITY_EVEN : USART_PARITY_NONE; uartPort->Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; uartPort->Handle.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; uartPort->Handle.Init.Mode = 0; if (uartPort->port.mode & MODE_RX) uartPort->Handle.Init.Mode |= UART_MODE_RX; if (uartPort->port.mode & MODE_TX) uartPort->Handle.Init.Mode |= UART_MODE_TX; usartConfigurePinInversion(uartPort); #ifdef TARGET_USART_CONFIG usartTargetConfigure(uartPort); #endif if (uartPort->port.options & SERIAL_BIDIR) { HAL_HalfDuplex_Init(&uartPort->Handle); } else { HAL_UART_Init(&uartPort->Handle); } // Receive DMA or IRQ if (uartPort->port.mode & MODE_RX) { if (uartPort->rxDMAStream) { uartPort->rxDMAHandle.Instance = uartPort->rxDMAStream; uartPort->rxDMAHandle.Init.Channel = uartPort->rxDMAChannel; uartPort->rxDMAHandle.Init.Direction = DMA_PERIPH_TO_MEMORY; uartPort->rxDMAHandle.Init.PeriphInc = DMA_PINC_DISABLE; uartPort->rxDMAHandle.Init.MemInc = DMA_MINC_ENABLE; uartPort->rxDMAHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; uartPort->rxDMAHandle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; uartPort->rxDMAHandle.Init.Mode = DMA_CIRCULAR; uartPort->rxDMAHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; uartPort->rxDMAHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL; uartPort->rxDMAHandle.Init.PeriphBurst = DMA_PBURST_SINGLE; uartPort->rxDMAHandle.Init.MemBurst = DMA_MBURST_SINGLE; uartPort->rxDMAHandle.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_DeInit(&uartPort->rxDMAHandle); HAL_DMA_Init(&uartPort->rxDMAHandle); /* Associate the initialized DMA handle to the UART handle */ __HAL_LINKDMA(&uartPort->Handle, hdmarx, uartPort->rxDMAHandle); HAL_UART_Receive_DMA(&uartPort->Handle, (uint8_t*)uartPort->port.rxBuffer, uartPort->port.rxBufferSize); uartPort->rxDMAPos = __HAL_DMA_GET_COUNTER(&uartPort->rxDMAHandle); } else { /* Enable the UART Parity Error Interrupt */ SET_BIT(uartPort->USARTx->CR1, USART_CR1_PEIE); /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */ SET_BIT(uartPort->USARTx->CR3, USART_CR3_EIE); /* Enable the UART Data Register not empty Interrupt */ SET_BIT(uartPort->USARTx->CR1, USART_CR1_RXNEIE); } } // Transmit DMA or IRQ if (uartPort->port.mode & MODE_TX) { if (uartPort->txDMAStream) { uartPort->txDMAHandle.Instance = uartPort->txDMAStream; uartPort->txDMAHandle.Init.Channel = uartPort->txDMAChannel; uartPort->txDMAHandle.Init.Direction = DMA_MEMORY_TO_PERIPH; uartPort->txDMAHandle.Init.PeriphInc = DMA_PINC_DISABLE; uartPort->txDMAHandle.Init.MemInc = DMA_MINC_ENABLE; uartPort->txDMAHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; uartPort->txDMAHandle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; uartPort->txDMAHandle.Init.Mode = DMA_NORMAL; uartPort->txDMAHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; uartPort->txDMAHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL; uartPort->txDMAHandle.Init.PeriphBurst = DMA_PBURST_SINGLE; uartPort->txDMAHandle.Init.MemBurst = DMA_MBURST_SINGLE; uartPort->txDMAHandle.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_DeInit(&uartPort->txDMAHandle); HAL_StatusTypeDef status = HAL_DMA_Init(&uartPort->txDMAHandle); if (status != HAL_OK) { while (1); } /* Associate the initialized DMA handle to the UART handle */ __HAL_LINKDMA(&uartPort->Handle, hdmatx, uartPort->txDMAHandle); __HAL_DMA_SET_COUNTER(&uartPort->txDMAHandle, 0); } else { /* Enable the UART Transmit Data Register Empty Interrupt */ SET_BIT(uartPort->USARTx->CR1, USART_CR1_TXEIE); } } return; }
/** * @brief I2Cx MSP Initialization * @param hi2c: I2C handle * @retval None */ static void I2Cx_MspInit(I2C_HandleTypeDef *hi2c) { GPIO_InitTypeDef GPIO_InitStruct; #ifdef EE_M24LR64 static DMA_HandleTypeDef hdma_tx; static DMA_HandleTypeDef hdma_rx; I2C_HandleTypeDef* pI2cHandle; pI2cHandle = &I2cHandle; #endif /* EE_M24LR64 */ if (hi2c->Instance == DISCOVERY_I2Cx) { /* Configure the GPIOs ---------------------------------------------------*/ /* Enable GPIO clock */ DISCOVERY_I2Cx_SDA_GPIO_CLK_ENABLE(); DISCOVERY_I2Cx_SCL_GPIO_CLK_ENABLE(); /* Configure I2C Tx as alternate function */ GPIO_InitStruct.Pin = DISCOVERY_I2Cx_SCL_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = DISCOVERY_I2Cx_SCL_SDA_AF; HAL_GPIO_Init(DISCOVERY_I2Cx_SCL_GPIO_PORT, &GPIO_InitStruct); /* Configure I2C Rx as alternate function */ GPIO_InitStruct.Pin = DISCOVERY_I2Cx_SDA_PIN; HAL_GPIO_Init(DISCOVERY_I2Cx_SDA_GPIO_PORT, &GPIO_InitStruct); /* Configure the Discovery I2Cx peripheral -------------------------------*/ /* Enable I2C3 clock */ DISCOVERY_I2Cx_CLOCK_ENABLE(); /* Force the I2C Peripheral Clock Reset */ DISCOVERY_I2Cx_FORCE_RESET(); /* Release the I2C Peripheral Clock Reset */ DISCOVERY_I2Cx_RELEASE_RESET(); /* Enable and set Discovery I2Cx Interrupt to the highest priority */ HAL_NVIC_SetPriority(DISCOVERY_I2Cx_EV_IRQn, 0x00, 0); HAL_NVIC_EnableIRQ(DISCOVERY_I2Cx_EV_IRQn); /* Enable and set Discovery I2Cx Interrupt to the highest priority */ HAL_NVIC_SetPriority(DISCOVERY_I2Cx_ER_IRQn, 0x00, 0); HAL_NVIC_EnableIRQ(DISCOVERY_I2Cx_ER_IRQn); #ifdef EE_M24LR64 /* I2C DMA TX and RX channels configuration */ /* Enable the DMA clock */ EEPROM_I2C_DMA_CLK_ENABLE(); /* Configure the DMA stream for the EE I2C peripheral TX direction */ /* Configure the DMA Stream */ hdma_tx.Instance = EEPROM_I2C_DMA_STREAM_TX; /* Set the parameters to be configured */ hdma_tx.Init.Channel = EEPROM_I2C_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_VERY_HIGH; hdma_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_tx.Init.MemBurst = DMA_MBURST_SINGLE; hdma_tx.Init.PeriphBurst = DMA_PBURST_SINGLE; /* Associate the initilalized hdma_tx handle to the the pI2cHandle handle */ __HAL_LINKDMA(pI2cHandle, hdmatx, hdma_tx); /* Configure the DMA Stream */ HAL_DMA_Init(&hdma_tx); /* Configure and enable I2C DMA TX Channel interrupt */ HAL_NVIC_SetPriority((IRQn_Type)(EEPROM_I2C_DMA_TX_IRQn), EEPROM_I2C_DMA_PREPRIO, 0); HAL_NVIC_EnableIRQ((IRQn_Type)(EEPROM_I2C_DMA_TX_IRQn)); /* Configure the DMA stream for the EE I2C peripheral TX direction */ /* Configure the DMA Stream */ hdma_rx.Instance = EEPROM_I2C_DMA_STREAM_RX; /* Set the parameters to be configured */ hdma_rx.Init.Channel = EEPROM_I2C_DMA_CHANNEL; 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_VERY_HIGH; hdma_rx.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_rx.Init.MemBurst = DMA_MBURST_SINGLE; hdma_rx.Init.PeriphBurst = DMA_PBURST_SINGLE; /* Associate the initilalized hdma_rx handle to the the pI2cHandle handle*/ __HAL_LINKDMA(pI2cHandle, hdmarx, hdma_rx); /* Configure the DMA Stream */ HAL_DMA_Init(&hdma_rx); /* Configure and enable I2C DMA RX Channel interrupt */ HAL_NVIC_SetPriority((IRQn_Type)(EEPROM_I2C_DMA_RX_IRQn), EEPROM_I2C_DMA_PREPRIO, 0); HAL_NVIC_EnableIRQ((IRQn_Type)(EEPROM_I2C_DMA_RX_IRQn)); #endif /* EE_M24LR64 */ } }
//Initializes communication peripheral and buffers void xb_Init(void){ GPIO_InitTypeDef GPIO_InitStructure = {0}; DMA_HandleTypeDef hDMA_RX = {0}; //Configure GPIO pins for UART XB_PORT_ENPERCLK(); GPIO_InitStructure.Pin = XB_PIN_TX | XB_PIN_RX; GPIO_InitStructure.Mode = GPIO_MODE_AF_PP; GPIO_InitStructure.Pull = GPIO_NOPULL; GPIO_InitStructure.Speed = GPIO_SPEED_HIGH; GPIO_InitStructure.Alternate = XB_PORT_AF; HAL_GPIO_Init(XB_PORT_INST, &GPIO_InitStructure); //Configure USART peripheral XB_USART_INST->CR2 = 0xFF000000; //I wish I could remember what this line was supposed to do then ... :) XB_USART_ENPERCLK(); xb_ComPort.Instance = XB_USART_INST; xb_ComPort.Init.BaudRate = XB_USART_BAUDRATE; xb_ComPort.Init.WordLength = UART_WORDLENGTH_8B; xb_ComPort.Init.StopBits = UART_STOPBITS_1; xb_ComPort.Init.Parity = UART_PARITY_NONE; xb_ComPort.Init.HwFlowCtl = UART_HWCONTROL_NONE; xb_ComPort.Init.Mode = UART_MODE_TX_RX; HAL_UART_Init(&xb_ComPort); //Set character match and disable error interrupts (this can be done only while Receiver is enabled and USART is disabled (RE=1, UE=0) __HAL_UART_DISABLE(&xb_ComPort); //__HAL_UART_DISABLE_IT(&ComPort, UART_IT_ERR); MODIFY_REG(XB_USART_INST->CR3, USART_CR3_OVRDIS, USART_CR3_OVRDIS); MODIFY_REG(XB_USART_INST->CR2, USART_CR2_ADD, ((unsigned)XB_ENDOFCMDCHAR << UART_CR2_ADDRESS_LSB_POS)); __HAL_UART_ENABLE(&xb_ComPort); //Configure DMA for TX and RX XB_DMA_ENPERCLK(); xb_hDMA_TX.Instance = XB_DMA_TX; xb_hDMA_TX.Init.Direction = DMA_MEMORY_TO_PERIPH; xb_hDMA_TX.Init.PeriphInc = DMA_PINC_DISABLE; xb_hDMA_TX.Init.MemInc = DMA_MINC_ENABLE; xb_hDMA_TX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; xb_hDMA_TX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; xb_hDMA_TX.Init.Mode = DMA_NORMAL;//DMA_CIRCULAR; xb_hDMA_TX.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&xb_hDMA_TX); __HAL_LINKDMA(&xb_ComPort, hdmatx, xb_hDMA_TX); HAL_NVIC_SetPriority(XB_DMA_TX_IRQN, 3, 1); HAL_NVIC_EnableIRQ(XB_DMA_TX_IRQN); hDMA_RX.Instance = XB_DMA_RX; 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_CIRCULAR; hDMA_RX.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&hDMA_RX); __HAL_LINKDMA(&xb_ComPort, hdmarx, hDMA_RX); //Enable USART interrupts HAL_NVIC_SetPriority(XB_USART_IRQN, 3, 3); HAL_NVIC_EnableIRQ(XB_USART_IRQN); __HAL_UART_ENABLE_IT(&xb_ComPort, UART_IT_CM); //Starts port reading HAL_UART_Receive_DMA(&xb_ComPort, xb_RxBuffer, XB_RXBUFSIZE); xb_MutexId = osMutexCreate(osMutex(xb_Mutex)); }
/** * @brief I2C MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - DMA configuration for transmission request by peripheral * - NVIC configuration for DMA interrupt request enable * @param hi2c: I2C handle pointer * @retval None */ void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) { static DMA_HandleTypeDef hdma_tx; static DMA_HandleTypeDef hdma_rx; GPIO_InitTypeDef GPIO_InitStruct; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO TX/RX clock */ I2Cx_SCL_GPIO_CLK_ENABLE(); I2Cx_SDA_GPIO_CLK_ENABLE(); /* Enable I2Cx clock */ I2Cx_CLK_ENABLE(); /* Enable DMAx clock */ I2Cx_DMA_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* I2C TX GPIO pin configuration */ GPIO_InitStruct.Pin = I2Cx_SCL_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = I2Cx_SCL_AF; HAL_GPIO_Init(I2Cx_SCL_GPIO_PORT, &GPIO_InitStruct); /* I2C RX GPIO pin configuration */ GPIO_InitStruct.Pin = I2Cx_SDA_PIN; GPIO_InitStruct.Alternate = I2Cx_SDA_AF; HAL_GPIO_Init(I2Cx_SDA_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the DMA ##################################################*/ /* Configure the DMA handler for Transmission process */ hdma_tx.Instance = I2Cx_DMA_CHANNEL_TX; 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; HAL_DMA_Init(&hdma_tx); /* Associate the initialized DMA handle to the the I2C handle */ __HAL_LINKDMA(hi2c, hdmatx, hdma_tx); /* Configure the DMA handler for Transmission process */ hdma_rx.Instance = I2Cx_DMA_CHANNEL_RX; 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; HAL_DMA_Init(&hdma_rx); /* Associate the initialized DMA handle to the the I2C handle */ __HAL_LINKDMA(hi2c, hdmarx, hdma_rx); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt (I2C1_TX) */ HAL_NVIC_SetPriority(I2Cx_DMA_TX_IRQn, 0, 1); HAL_NVIC_EnableIRQ(I2Cx_DMA_TX_IRQn); /* NVIC configuration for DMA transfer complete interrupt (I2C1_RX) */ HAL_NVIC_SetPriority(I2Cx_DMA_RX_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2Cx_DMA_RX_IRQn); }
/** * @brief UART MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * - DMA configuration for transmission request by peripheral * - NVIC configuration for DMA interrupt request enable * @param huart: UART handle pointer * @retval None */ void HAL_UART_MspInit(UART_HandleTypeDef *huart) { static DMA_HandleTypeDef hdma_tx; static DMA_HandleTypeDef hdma_rx; GPIO_InitTypeDef GPIO_InitStruct; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO clock */ USARTx_TX_GPIO_CLK_ENABLE(); USARTx_RX_GPIO_CLK_ENABLE(); /* Enable USARTx clock */ USARTx_CLK_ENABLE(); /* Enable DMA clock */ DMAx_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* UART TX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_TX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct); /* UART RX GPIO pin configuration */ GPIO_InitStruct.Pin = USARTx_RX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct); /*##-3- Configure the DMA ##################################################*/ /* Configure the DMA handler for Transmission process */ hdma_tx.Instance = USARTx_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; HAL_DMA_Init(&hdma_tx); /* Associate the initialized DMA handle to the UART handle */ __HAL_LINKDMA(huart, hdmatx, hdma_tx); /* Configure the DMA handler for reception process */ hdma_rx.Instance = USARTx_RX_DMA_CHANNEL; 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; HAL_DMA_Init(&hdma_rx); /* Associate the initialized DMA handle to the the UART handle */ __HAL_LINKDMA(huart, hdmarx, hdma_rx); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt (USARTx_TX) */ HAL_NVIC_SetPriority(USARTx_DMA_TX_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USARTx_DMA_TX_IRQn); /* NVIC configuration for DMA transfer complete interrupt (USARTx_RX) */ HAL_NVIC_SetPriority(USARTx_DMA_RX_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USARTx_DMA_RX_IRQn); /* NVIC for USART, to catch the TX complete */ HAL_NVIC_SetPriority(USARTx_IRQn, 0, 1); HAL_NVIC_EnableIRQ(USARTx_IRQn); }
/** * @brief Initializes the SD MSP. * @param None * @retval None */ static void SD_MspInit(void) { static DMA_HandleTypeDef dmaRxHandle; static DMA_HandleTypeDef dmaTxHandle; GPIO_InitTypeDef GPIO_Init_Structure; SD_HandleTypeDef *hsd = &uSdHandle; /* Enable SDIO clock */ __SDIO_CLK_ENABLE(); /* Enable DMA2 clocks */ __DMAx_TxRx_CLK_ENABLE(); /* Enable GPIOs clock */ __GPIOC_CLK_ENABLE(); __GPIOD_CLK_ENABLE(); __SD_DETECT_GPIO_CLK_ENABLE(); /* Common GPIO configuration */ GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF12_SDIO; /* GPIOC configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12; HAL_GPIO_Init(GPIOC, &GPIO_Init_Structure); /* GPIOD configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_2; HAL_GPIO_Init(GPIOD, &GPIO_Init_Structure); /* SD Card detect pin configuration */ GPIO_Init_Structure.Mode = GPIO_MODE_INPUT; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Pin = SD_DETECT_PIN; HAL_GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_Init_Structure); /* NVIC configuration for SDIO interrupts */ HAL_NVIC_SetPriority(SDIO_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDIO_IRQn); /* Configure DMA Rx parameters */ dmaRxHandle.Init.Channel = SD_DMAx_Rx_CHANNEL; dmaRxHandle.Init.Direction = DMA_PERIPH_TO_MEMORY; dmaRxHandle.Init.PeriphInc = DMA_PINC_DISABLE; dmaRxHandle.Init.MemInc = DMA_MINC_ENABLE; dmaRxHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dmaRxHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dmaRxHandle.Init.Mode = DMA_PFCTRL; dmaRxHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dmaRxHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dmaRxHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dmaRxHandle.Init.MemBurst = DMA_MBURST_INC4; dmaRxHandle.Init.PeriphBurst = DMA_PBURST_INC4; dmaRxHandle.Instance = SD_DMAx_Rx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmarx, dmaRxHandle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dmaRxHandle); /* Configure the DMA stream */ HAL_DMA_Init(&dmaRxHandle); /* Configure DMA Tx parameters */ dmaTxHandle.Init.Channel = SD_DMAx_Tx_CHANNEL; dmaTxHandle.Init.Direction = DMA_MEMORY_TO_PERIPH; dmaTxHandle.Init.PeriphInc = DMA_PINC_DISABLE; dmaTxHandle.Init.MemInc = DMA_MINC_ENABLE; dmaTxHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dmaTxHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dmaTxHandle.Init.Mode = DMA_PFCTRL; dmaTxHandle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dmaTxHandle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dmaTxHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dmaTxHandle.Init.MemBurst = DMA_MBURST_INC4; dmaTxHandle.Init.PeriphBurst = DMA_PBURST_INC4; dmaTxHandle.Instance = SD_DMAx_Tx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmatx, dmaTxHandle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dmaTxHandle); /* Configure the DMA stream */ HAL_DMA_Init(&dmaTxHandle); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD_DMAx_Rx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD_DMAx_Rx_IRQn); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD_DMAx_Tx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD_DMAx_Tx_IRQn); }
void HAL_DCMI_MspInit(DCMI_HandleTypeDef* hdcmi) { GPIO_InitTypeDef GPIO_InitStruct; if(hdcmi->Instance==DCMI) { /* USER CODE BEGIN DCMI_MspInit 0 */ /* USER CODE END DCMI_MspInit 0 */ /* Peripheral clock enable */ __DCMI_CLK_ENABLE(); /**DCMI GPIO Configuration PE4 ------> DCMI_D4 PE5 ------> DCMI_D6 PE6 ------> DCMI_D7 PA4 ------> DCMI_HSYNC PA6 ------> DCMI_PIXCK PC6 ------> DCMI_D0 PC7 ------> DCMI_D1 PC8 ------> DCMI_D2 PC9 ------> DCMI_D3 PB6 ------> DCMI_D5 PB7 ------> DCMI_VSYNC */ GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOE, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF13_DCMI; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_dcmi.Instance = DMA2_Stream1; hdma_dcmi.Init.Channel = DMA_CHANNEL_1; hdma_dcmi.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_dcmi.Init.PeriphInc = DMA_PINC_DISABLE; hdma_dcmi.Init.MemInc = DMA_MINC_ENABLE; hdma_dcmi.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdma_dcmi.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_dcmi.Init.Mode = DMA_NORMAL; hdma_dcmi.Init.Priority = DMA_PRIORITY_VERY_HIGH; hdma_dcmi.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_dcmi.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_dcmi.Init.MemBurst = DMA_MBURST_SINGLE; hdma_dcmi.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_dcmi); __HAL_LINKDMA(hdcmi,DMA_Handle,hdma_dcmi); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(DCMI_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DCMI_IRQn); /* USER CODE BEGIN DCMI_MspInit 1 */ /* USER CODE END DCMI_MspInit 1 */ } }
void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp) { static DMA_HandleTypeDef hdmaIn; static DMA_HandleTypeDef hdmaOut; /*##-1- Enable peripherals Clock ###########################################*/ /* Enable CRYP clock */ __HAL_RCC_CRYP_CLK_ENABLE(); /* Enable DMA2 clock */ __HAL_RCC_DMA2_CLK_ENABLE(); /*##-2- Configure the DMA streams ##########################################*/ /***************** Configure common DMA In parameters ***********************/ hdmaIn.Init.Channel = DMA_CHANNEL_2; hdmaIn.Init.Direction = DMA_MEMORY_TO_PERIPH; hdmaIn.Init.PeriphInc = DMA_PINC_DISABLE; hdmaIn.Init.MemInc = DMA_MINC_ENABLE; hdmaIn.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdmaIn.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; hdmaIn.Init.Mode = DMA_NORMAL; hdmaIn.Init.Priority = DMA_PRIORITY_HIGH; hdmaIn.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdmaIn.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdmaIn.Init.MemBurst = DMA_MBURST_SINGLE; hdmaIn.Init.PeriphBurst = DMA_PBURST_SINGLE; hdmaIn.Instance = DMA2_Stream6; /* Associate the DMA handle */ __HAL_LINKDMA(hcryp, hdmain, hdmaIn); /* Configure the DMA Stream */ HAL_DMA_Init(hcryp->hdmain); /* NVIC configuration for DMA Input data interrupt */ HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0x0F, 0); HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn); /***************** Configure common DMA Out parameters **********************/ hdmaOut.Init.Channel = DMA_CHANNEL_2; hdmaOut.Init.Direction = DMA_PERIPH_TO_MEMORY; hdmaOut.Init.PeriphInc = DMA_PINC_DISABLE; hdmaOut.Init.MemInc = DMA_MINC_ENABLE; hdmaOut.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdmaOut.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; hdmaOut.Init.Mode = DMA_NORMAL; hdmaOut.Init.Priority = DMA_PRIORITY_VERY_HIGH; hdmaOut.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdmaOut.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; hdmaOut.Init.MemBurst = DMA_MBURST_SINGLE; hdmaOut.Init.PeriphBurst = DMA_PBURST_SINGLE; hdmaOut.Instance = DMA2_Stream5; /* Associate the DMA handle */ __HAL_LINKDMA(hcryp, hdmaout, hdmaOut); /* Configure the DMA Stream */ HAL_DMA_Init(&hdmaOut); /*##-3- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA output data interrupt */ HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 0x0F, 0); HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn); }
/** * @brief Initializes the SD MSP. * @param hsd: SD handle * @retval None */ __weak void BSP_SD_MspInit(SD_HandleTypeDef *hsd, void *Params) { static DMA_HandleTypeDef dma_rx_handle; static DMA_HandleTypeDef dma_tx_handle; static DMA_HandleTypeDef dma_rx_handle2; static DMA_HandleTypeDef dma_tx_handle2; GPIO_InitTypeDef gpio_init_structure; /* Camera has to be powered down as some signals use same GPIOs between * SD card and camera bus. Camera drives its signals to low impedance * when powered ON. So the camera is powered off to let its signals * in high impedance */ /* Camera power down sequence */ BSP_IO_ConfigPin(RSTI_PIN, IO_MODE_OUTPUT); BSP_IO_ConfigPin(XSDN_PIN, IO_MODE_OUTPUT); /* De-assert the camera STANDBY pin (active high) */ BSP_IO_WritePin(XSDN_PIN, BSP_IO_PIN_RESET); /* Assert the camera RSTI pin (active low) */ BSP_IO_WritePin(RSTI_PIN, BSP_IO_PIN_RESET); if(hsd->Instance == SDMMC1) { /* Enable SDIO clock */ __HAL_RCC_SDMMC1_CLK_ENABLE(); /* Enable DMA2 clocks */ __DMAx_TxRx_CLK_ENABLE(); /* Enable GPIOs clock */ __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); /* Common GPIO configuration */ gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = GPIO_AF12_SDMMC1; /* GPIOC configuration: SD1_D0, SD1_D1, SD1_D2, SD1_D3 and SD1_CLK pins */ gpio_init_structure.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12; HAL_GPIO_Init(GPIOC, &gpio_init_structure); /* GPIOD configuration: SD1_CMD pin */ gpio_init_structure.Pin = GPIO_PIN_2; HAL_GPIO_Init(GPIOD, &gpio_init_structure); /* NVIC configuration for SDIO interrupts */ HAL_NVIC_SetPriority(SDMMC1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDMMC1_IRQn); dma_rx_handle.Init.Channel = SD1_DMAx_Rx_CHANNEL; dma_rx_handle.Init.Direction = DMA_PERIPH_TO_MEMORY; dma_rx_handle.Init.PeriphInc = DMA_PINC_DISABLE; dma_rx_handle.Init.MemInc = DMA_MINC_ENABLE; dma_rx_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_rx_handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_rx_handle.Init.Mode = DMA_PFCTRL; dma_rx_handle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dma_rx_handle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dma_rx_handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_rx_handle.Init.MemBurst = DMA_MBURST_INC4; dma_rx_handle.Init.PeriphBurst = DMA_PBURST_INC4; dma_rx_handle.Instance = SD1_DMAx_Rx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmarx, dma_rx_handle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_rx_handle); /* Configure the DMA stream */ HAL_DMA_Init(&dma_rx_handle); dma_tx_handle.Init.Channel = SD1_DMAx_Tx_CHANNEL; dma_tx_handle.Init.Direction = DMA_MEMORY_TO_PERIPH; dma_tx_handle.Init.PeriphInc = DMA_PINC_DISABLE; dma_tx_handle.Init.MemInc = DMA_MINC_ENABLE; dma_tx_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_tx_handle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_tx_handle.Init.Mode = DMA_PFCTRL; dma_tx_handle.Init.Priority = DMA_PRIORITY_VERY_HIGH; dma_tx_handle.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dma_tx_handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_tx_handle.Init.MemBurst = DMA_MBURST_INC4; dma_tx_handle.Init.PeriphBurst = DMA_PBURST_INC4; dma_tx_handle.Instance = SD1_DMAx_Tx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmatx, dma_tx_handle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_tx_handle); /* Configure the DMA stream */ HAL_DMA_Init(&dma_tx_handle); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD1_DMAx_Rx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD1_DMAx_Rx_IRQn); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD1_DMAx_Tx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD1_DMAx_Tx_IRQn); } else { /* Enable SDIO clock */ __HAL_RCC_SDMMC2_CLK_ENABLE(); /* Enable DMA2 clocks */ __DMAx_TxRx_CLK_ENABLE(); /* Enable GPIOs clock */ __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOD_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); /* Common GPIO configuration */ gpio_init_structure.Mode = GPIO_MODE_AF_PP; gpio_init_structure.Pull = GPIO_PULLUP; gpio_init_structure.Speed = GPIO_SPEED_HIGH; gpio_init_structure.Alternate = GPIO_AF10_SDMMC2; /* GPIOB configuration: SD2_D2 and SD2_D3 pins */ gpio_init_structure.Pin = GPIO_PIN_3 | GPIO_PIN_4; HAL_GPIO_Init(GPIOB, &gpio_init_structure); /* GPIOD configuration: SD2_CLK and SD2_CMD pins */ gpio_init_structure.Pin = GPIO_PIN_6 | GPIO_PIN_7; gpio_init_structure.Alternate = GPIO_AF11_SDMMC2; HAL_GPIO_Init(GPIOD, &gpio_init_structure); /* GPIOG configuration: SD2_D0 and SD2_D1 pins */ gpio_init_structure.Pin = GPIO_PIN_9 | GPIO_PIN_10; HAL_GPIO_Init(GPIOG, &gpio_init_structure); /* NVIC configuration for SDIO interrupts */ HAL_NVIC_SetPriority(SDMMC2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SDMMC2_IRQn); dma_rx_handle2.Init.Channel = SD2_DMAx_Rx_CHANNEL; dma_rx_handle2.Init.Direction = DMA_PERIPH_TO_MEMORY; dma_rx_handle2.Init.PeriphInc = DMA_PINC_DISABLE; dma_rx_handle2.Init.MemInc = DMA_MINC_ENABLE; dma_rx_handle2.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_rx_handle2.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_rx_handle2.Init.Mode = DMA_PFCTRL; dma_rx_handle2.Init.Priority = DMA_PRIORITY_VERY_HIGH; dma_rx_handle2.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dma_rx_handle2.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_rx_handle2.Init.MemBurst = DMA_MBURST_INC4; dma_rx_handle2.Init.PeriphBurst = DMA_PBURST_INC4; dma_rx_handle2.Instance = SD2_DMAx_Rx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmarx, dma_rx_handle2); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_rx_handle2); /* Configure the DMA stream */ HAL_DMA_Init(&dma_rx_handle2); dma_tx_handle2.Init.Channel = SD2_DMAx_Tx_CHANNEL; dma_tx_handle2.Init.Direction = DMA_MEMORY_TO_PERIPH; dma_tx_handle2.Init.PeriphInc = DMA_PINC_DISABLE; dma_tx_handle2.Init.MemInc = DMA_MINC_ENABLE; dma_tx_handle2.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; dma_tx_handle2.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; dma_tx_handle2.Init.Mode = DMA_PFCTRL; dma_tx_handle2.Init.Priority = DMA_PRIORITY_VERY_HIGH; dma_tx_handle2.Init.FIFOMode = DMA_FIFOMODE_ENABLE; dma_tx_handle2.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dma_tx_handle2.Init.MemBurst = DMA_MBURST_INC4; dma_tx_handle2.Init.PeriphBurst = DMA_PBURST_INC4; dma_tx_handle2.Instance = SD2_DMAx_Tx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsd, hdmatx, dma_tx_handle2); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dma_tx_handle2); /* Configure the DMA stream */ HAL_DMA_Init(&dma_tx_handle2); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD2_DMAx_Rx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD2_DMAx_Rx_IRQn); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SD2_DMAx_Tx_IRQn, 6, 0); HAL_NVIC_EnableIRQ(SD2_DMAx_Tx_IRQn); } }
/** * @brief Initializes SRAM MSP. * @param hsram: SRAM handle * @retval None */ static void SRAM_MspInit(void) { static DMA_HandleTypeDef dmaHandle; GPIO_InitTypeDef GPIO_Init_Structure; SRAM_HandleTypeDef *hsram = &sramHandle; /* Enable FMC clock */ __FSMC_CLK_ENABLE(); /* Enable chosen DMAx clock */ __SRAM_DMAx_CLK_ENABLE(); /* Enable GPIOs clock */ __GPIOD_CLK_ENABLE(); __GPIOE_CLK_ENABLE(); __GPIOF_CLK_ENABLE(); __GPIOG_CLK_ENABLE(); /* Common GPIO configuration */ GPIO_Init_Structure.Mode = GPIO_MODE_AF_PP; GPIO_Init_Structure.Pull = GPIO_PULLUP; GPIO_Init_Structure.Speed = GPIO_SPEED_HIGH; GPIO_Init_Structure.Alternate = GPIO_AF12_FSMC; /* GPIOD configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_8 |\ GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 |\ GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOD, &GPIO_Init_Structure); /* GPIOE configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3| GPIO_PIN_4 | GPIO_PIN_7 |\ GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 |\ GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOE, &GPIO_Init_Structure); /* GPIOF configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |\ GPIO_PIN_5 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15; HAL_GPIO_Init(GPIOF, &GPIO_Init_Structure); /* GPIOG configuration */ GPIO_Init_Structure.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |\ GPIO_PIN_5 | GPIO_PIN_9; HAL_GPIO_Init(GPIOG, &GPIO_Init_Structure); /* Configure common DMA parameters */ dmaHandle.Init.Channel = SRAM_DMAx_CHANNEL; dmaHandle.Init.Direction = DMA_MEMORY_TO_MEMORY; dmaHandle.Init.PeriphInc = DMA_PINC_ENABLE; dmaHandle.Init.MemInc = DMA_MINC_ENABLE; dmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; dmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; dmaHandle.Init.Mode = DMA_NORMAL; dmaHandle.Init.Priority = DMA_PRIORITY_HIGH; dmaHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; dmaHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; dmaHandle.Init.MemBurst = DMA_MBURST_INC8; dmaHandle.Init.PeriphBurst = DMA_PBURST_INC8; dmaHandle.Instance = SRAM_DMAx_STREAM; /* Associate the DMA handle */ __HAL_LINKDMA(hsram, hdma, dmaHandle); /* Deinitialize the stream for new transfer */ HAL_DMA_DeInit(&dmaHandle); /* Configure the DMA stream */ HAL_DMA_Init(&dmaHandle); /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(SRAM_DMAx_IRQn, 5, 0); HAL_NVIC_EnableIRQ(SRAM_DMAx_IRQn); }
/** * @brief UArt MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * @param[in] huart UART handle pointer * @retval None */ void HAL_UART_MspInit(UART_HandleTypeDef* huart) { GPIO_InitTypeDef GPIO_InitStruct; if(huart->Instance == BSP_UART_DEBUG) { /* Peripheral clock enable */ __BSP_UART_DEBUG_CLK_ENABLE(); /* Enable GPIO TX/RX clock */ __BSP_UART_DEBUG_TX_GPIO_CLK_ENABLE(); __BSP_UART_DEBUG_RX_GPIO_CLK_ENABLE(); /* USART TX GPIO Configuration */ GPIO_InitStruct.Pin = BSP_UART_DEBUG_TX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_UART_DEBUG_TX_AF; HAL_GPIO_Init(BSP_UART_DEBUG_TX_PORT, &GPIO_InitStruct); /* USART RX GPIO Configuration */ GPIO_InitStruct.Pin = BSP_UART_DEBUG_RX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_UART_DEBUG_RX_AF; HAL_GPIO_Init(BSP_UART_DEBUG_RX_PORT, &GPIO_InitStruct); /* Configure the NVIC for UART */ HAL_NVIC_SetPriority(BSP_UART_DEBUG_IRQn, 3, 0); HAL_NVIC_EnableIRQ(BSP_UART_DEBUG_IRQn); } else if(huart->Instance == BSP_WIFI_UART) { DMA_HandleTypeDef *pRxDmaHandle = &(gBspWifiData.rxDmaHandle); DMA_HandleTypeDef *pTxDmaHandle = &(gBspWifiData.txDmaHandle); /* Peripheral clock enable */ __BSP_WIFI_UART_CLK_ENABLE(); /* Enable GPIO TX/RX clock */ __BSP_WIFI_UART_CTS_GPIO_CLK_ENABLE(); __BSP_WIFI_UART_RTS_GPIO_CLK_ENABLE(); __BSP_WIFI_UART_TX_GPIO_CLK_ENABLE(); __BSP_WIFI_UART_RX_GPIO_CLK_ENABLE(); __BSP_WIFI_UART_DMA_CLK_ENABLE(); /* USART CTS GPIO Configuration */ GPIO_InitStruct.Pin = BSP_WIFI_UART_CTS_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_WIFI_UART_CTS_AF; HAL_GPIO_Init(BSP_WIFI_UART_CTS_PORT, &GPIO_InitStruct); /* USART RTS GPIO Configuration */ GPIO_InitStruct.Pin = BSP_WIFI_UART_RTS_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_WIFI_UART_RTS_AF; HAL_GPIO_Init(BSP_WIFI_UART_RTS_PORT, &GPIO_InitStruct); /* USART TX GPIO Configuration */ GPIO_InitStruct.Pin = BSP_WIFI_UART_TX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_WIFI_UART_TX_AF; HAL_GPIO_Init(BSP_WIFI_UART_TX_PORT, &GPIO_InitStruct); /* USART RX GPIO Configuration */ GPIO_InitStruct.Pin = BSP_WIFI_UART_RX_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = BSP_WIFI_UART_RX_AF; HAL_GPIO_Init(BSP_WIFI_UART_RX_PORT, &GPIO_InitStruct); pRxDmaHandle->Instance = BSP_WIFI_UART_DMA_RX; pRxDmaHandle->Init.Channel = BSP_WIFI_UART_DMA_RX_CHANNEL; pRxDmaHandle->Init.Direction = DMA_PERIPH_TO_MEMORY; pRxDmaHandle->Init.PeriphInc = DMA_PINC_DISABLE; pRxDmaHandle->Init.MemInc = DMA_MINC_ENABLE; pRxDmaHandle->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; pRxDmaHandle->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; pRxDmaHandle->Init.Mode = DMA_NORMAL; pRxDmaHandle->Init.Priority = DMA_PRIORITY_HIGH; pRxDmaHandle->Init.FIFOMode = DMA_FIFOMODE_DISABLE; pRxDmaHandle->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; pRxDmaHandle->Init.MemBurst = DMA_MBURST_INC4; pRxDmaHandle->Init.PeriphBurst = DMA_PBURST_INC4; HAL_DMA_Init(pRxDmaHandle); __HAL_LINKDMA(huart, hdmarx, gBspWifiData.rxDmaHandle); pTxDmaHandle->Instance = BSP_WIFI_UART_DMA_TX; pTxDmaHandle->Init.Channel = BSP_WIFI_UART_DMA_TX_CHANNEL; pTxDmaHandle->Init.Direction = DMA_MEMORY_TO_PERIPH; pTxDmaHandle->Init.PeriphInc = DMA_PINC_DISABLE; pTxDmaHandle->Init.MemInc = DMA_MINC_ENABLE; pTxDmaHandle->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; pTxDmaHandle->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; pTxDmaHandle->Init.Mode = DMA_NORMAL; pTxDmaHandle->Init.Priority = DMA_PRIORITY_LOW; pTxDmaHandle->Init.FIFOMode = DMA_FIFOMODE_DISABLE; pTxDmaHandle->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; pTxDmaHandle->Init.MemBurst = DMA_MBURST_INC4; pTxDmaHandle->Init.PeriphBurst = DMA_PBURST_INC4; HAL_DMA_Init(pTxDmaHandle); __HAL_LINKDMA(huart, hdmatx, gBspWifiData.txDmaHandle); HAL_NVIC_SetPriority(BSP_WIFI_UART_DMA_TX_IRQn, 4, 1); HAL_NVIC_EnableIRQ(BSP_WIFI_UART_DMA_TX_IRQn); /* NVIC configuration for DMA transfer complete interrupt (USARTx_RX) */ HAL_NVIC_SetPriority(BSP_WIFI_UART_DMA_RX_IRQn, 4, 0); HAL_NVIC_EnableIRQ(BSP_WIFI_UART_DMA_RX_IRQn); /* Configure the NVIC for UART */ HAL_NVIC_SetPriority(BSP_WIFI_UART_IRQn, 4, 1); HAL_NVIC_EnableIRQ(BSP_WIFI_UART_IRQn); } }