/** * Enable DMA controller clock * Configure DMA for memory to memory transfers * hdma_memtomem_dma2_stream0 */ void MX_DMA_Init(void) { /* DMA controller clock enable */ __HAL_RCC_DMA2_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); /* Configure DMA request hdma_memtomem_dma2_stream0 on DMA2_Stream0 */ hdma_memtomem_dma2_stream0.Instance = DMA2_Stream0; hdma_memtomem_dma2_stream0.Init.Channel = DMA_CHANNEL_0; hdma_memtomem_dma2_stream0.Init.Direction = DMA_MEMORY_TO_MEMORY; hdma_memtomem_dma2_stream0.Init.PeriphInc = DMA_PINC_ENABLE; hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_ENABLE; hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL; hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_memtomem_dma2_stream0.Init.FIFOMode = DMA_FIFOMODE_ENABLE; hdma_memtomem_dma2_stream0.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; hdma_memtomem_dma2_stream0.Init.MemBurst = DMA_MBURST_SINGLE; hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_SINGLE; HAL_DMA_Init(&hdma_memtomem_dma2_stream0); /* DMA interrupt init */ /* DMA1_Stream3_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn); /* DMA1_Stream4_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn); /* DMA2_Stream0_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn); }
void UART_Init() { __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); UART_HandleTypeDef huart2; huart2.Instance = USART2; huart2.Init.BaudRate = DEBUG_BAUD; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart2); USART2->CR3 |= USART_CR3_DMAT; // | USART_CR3_DMAR | USART_CR3_OVRDIS; GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); DMA1_Channel7->CCR = 0; DMA1_Channel7->CPAR = (uint32_t) & (USART2->DR); DMA1_Channel7->CNDTR = 0; DMA1_Channel7->CCR = DMA_CCR_MINC | DMA_CCR_DIR; DMA1->IFCR = DMA_IFCR_CTCIF7 | DMA_IFCR_CHTIF7 | DMA_IFCR_CGIF7; }
void DAC_DMA_init(void){ NVIC_InitTypeDef NVIC_InitStructure; GPIO_InitTypeDef GPIO_InitStruct; DAC_InitTypeDef DAC_INIT; DMA_InitTypeDef DMA_INIT; __HAL_RCC_DMA1_CLK_ENABLE(); __HAL_RCC_DAC_CLK_ENABLE(); /* DAC output pin */ GPIO_InitStruct.Pin = GPIO_PIN_4; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; //GPIO_InitStruct.Speed = GPIO_SPEED_FAST; /* 50MHz */ HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); DAC_INIT.DAC_Trigger = DAC_Trigger_T6_TRGO; DAC_INIT.DAC_WaveGeneration = DAC_WaveGeneration_None; DAC_INIT.DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bit0; DAC_INIT.DAC_OutputBuffer = DAC_OutputBuffer_Enable; DAC_Init(DAC_Channel_1, &DAC_INIT); DMA_DeInit(DMA1_Stream5); DMA_INIT.DMA_Channel = DMA_Channel_7; DMA_INIT.DMA_PeripheralBaseAddr = (uint32_t)DAC_DHR12R1_ADDR; DMA_INIT.DMA_Memory0BaseAddr = (uint32_t) &PINGBUF; //DMA_INIT.DMA_Memory0BaseAddr = (uint32_t) &function; DMA_INIT.DMA_DIR = DMA_DIR_MemoryToPeripheral; DMA_INIT.DMA_BufferSize = SINE_RES; DMA_INIT.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_INIT.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_INIT.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_INIT.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_INIT.DMA_Mode = DMA_Mode_Circular; DMA_INIT.DMA_Priority = DMA_Priority_High; DMA_INIT.DMA_FIFOMode = DMA_FIFOMode_Disable; DMA_INIT.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull; DMA_INIT.DMA_MemoryBurst = DMA_MemoryBurst_Single; DMA_INIT.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; DMA_Init(DMA1_Stream5, &DMA_INIT); DMA_DoubleBufferModeConfig(DMA1_Stream5, &PONGBUF,DMA_Memory_0); DMA_DoubleBufferModeCmd(DMA1_Stream5, ENABLE); DMA_ITConfig(DMA1_Stream5, DMA_IT_HT | DMA_IT_TC | DMA_IT_TE, ENABLE); DMA_Cmd(DMA1_Stream5, ENABLE); DAC_Cmd(DAC_Channel_1, ENABLE); DAC_DMACmd(DAC_Channel_1,ENABLE); NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream5_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); }
//****************************************************************************** // board_dac_enable_clock // // Enable the clock for a specifc DAC module. // Requires the caller previously invoked board_adc_get_status_block() // // Note that DAC_AUTO_MODULE = 0, so it is the first entry in the lookup table //****************************************************************************** void board_dac_enable_clocks (int module_id) { __HAL_RCC_DAC_CLK_ENABLE(); // Enable F0 DAC Periph clock // Enable the DAC module's associated DMA module's clocks __HAL_RCC_DMA1_CLK_ENABLE(); // Enable DMA clock - F4_46 has only // 1 DAC module with 2 channels }
/** * Enable DMA controller clock */ void MX_DMA_Init(void) { /* DMA controller clock enable */ __HAL_RCC_DMA1_CLK_ENABLE(); /* DMA interrupt init */ HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); }
static void init_BeforeADC(void) { GPIO_InitTypeDef GPIO_InitStruct; RCC_OscInitTypeDef RCC_OscInitStructure; RCC_PeriphCLKInitTypeDef PeriphClkInit; // __HAL_RCC_SYSCFG_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_ADC1_CLK_ENABLE(); PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC; PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV8; HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit); // HAL_RCC_GetOscConfig(&RCC_OscInitStructure); // RCC_OscInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSI; // RCC_OscInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; // RCC_OscInitStructure.HSIState = RCC_HSI_ON; // HAL_RCC_OscConfig(&RCC_OscInitStructure); GPIO_InitStruct.Pin = GPIO_PIN_10; #ifdef HEATBED_ENABLED GPIO_InitStruct.Pin |= GPIO_PIN_11; #endif #ifdef EXTRUDER_2_ENABLED GPIO_InitStruct.Pin |= GPIO_PIN_12; #endif #ifdef EXTRUDER_3_ENABLED GPIO_InitStruct.Pin |= GPIO_PIN_13; #endif GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); __HAL_RCC_DMA1_CLK_ENABLE(); DMA_HandleStruct.Instance = DMA1_Channel1; DMA_HandleStruct.Init.Direction = DMA_PERIPH_TO_MEMORY; DMA_HandleStruct.Init.PeriphInc = DMA_PINC_DISABLE; DMA_HandleStruct.Init.MemInc = DMA_MINC_ENABLE; DMA_HandleStruct.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; /* Transfer from ADC by half-word to match with ADC configuration: ADC resolution 10 or 12 bits */ DMA_HandleStruct.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; /* Transfer to memory by half-word to match with buffer variable type: half-word */ DMA_HandleStruct.Init.Mode = DMA_CIRCULAR; /* DMA in circular mode to match with ADC configuration: DMA continuous requests */ DMA_HandleStruct.Init.Priority = DMA_PRIORITY_HIGH; HAL_DMA_DeInit(&DMA_HandleStruct); HAL_DMA_Init(&DMA_HandleStruct); __HAL_LINKDMA(&ADC_HandleStruct, DMA_Handle, DMA_HandleStruct); HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 4, 0); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); }
/** * Enable DMA controller clock */ void MX_DMA_Init(void) { /* DMA controller clock enable */ __HAL_RCC_DMA1_CLK_ENABLE(); __HAL_RCC_DMA2_CLK_ENABLE(); /* DMA interrupt init */ /* DMA1_Stream0_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn); /* DMA1_Stream1_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn); /* DMA1_Stream2_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream2_IRQn); /* DMA1_Stream3_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn); /* DMA1_Stream4_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn); /* DMA1_Stream5_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn); /* DMA1_Stream6_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn); /* DMA1_Stream7_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn); /* DMA2_Stream0_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn); /* DMA2_Stream1_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn); /* DMA2_Stream2_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn); /* DMA2_Stream5_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn); /* DMA2_Stream6_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn); /* DMA2_Stream7_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn); }
/** * Enable DMA controller clock */ static void MX_DMA_Init(void) { /* DMA controller clock enable */ __HAL_RCC_DMA1_CLK_ENABLE(); /* DMA interrupt init */ /* DMA1_Channel5_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn); /* DMA1_Channel7_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 5, 0); HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn); }
/** * @brief TIM 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 * @param htim: TIM handle pointer * @retval None */ void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim) { GPIO_InitTypeDef GPIO_InitStruct; static DMA_HandleTypeDef hdma_tim; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* TIM2 clock enable */ __HAL_RCC_TIM2_CLK_ENABLE(); /* Enable GPIO TIM2_Channel3 (PORTB) Clock */ __HAL_RCC_GPIOB_CLK_ENABLE(); /* Enable DMA1 clock */ __HAL_RCC_DMA1_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* Configure TIM2_Channel3 in output, push-pull & alternate function mode */ GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF2_TIM2; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /*##-3- Configure the DMA stream ###########################################*/ /* Set the parameters to be configured */ hdma_tim.Init.Request = DMA_REQUEST_8; hdma_tim.Instance = DMA1_Channel1; hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE; hdma_tim.Init.MemInc = DMA_MINC_ENABLE; hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; hdma_tim.Init.Mode = DMA_CIRCULAR; hdma_tim.Init.Priority = DMA_PRIORITY_HIGH; /* Link hdma_tim to hdma[TIM_DMA_ID_CC3] (channel3) */ __HAL_LINKDMA(htim, hdma[TIM_DMA_ID_CC3], hdma_tim); /* Initialize TIMx DMA handle */ HAL_DMA_Init(htim->hdma[TIM_DMA_ID_CC3]); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); }
/** * @brief ADC MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * @param hadc: ADC handle pointer * @retval None */ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) { GPIO_InitTypeDef GPIO_InitStruct; static DMA_HandleTypeDef DmaHandle; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO clock */ ADCx_CHANNEL_GPIO_CLK_ENABLE(); /* ADC1 Periph clock enable */ ADCx_CLK_ENABLE(); /* Enable DMA1 clock */ __HAL_RCC_DMA1_CLK_ENABLE(); /*##-2- Configure peripheral GPIO ##########################################*/ /* ADC1 Channel9 GPIO pin configuration */ GPIO_InitStruct.Pin = ADCx_CHANNEL_PIN; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(ADCx_CHANNEL_GPIO_PORT, &GPIO_InitStruct); /*##- 3- Configure DMA #####################################################*/ /*********************** Configure DMA parameters ***************************/ DmaHandle.Instance = DMA1_Channel1; DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY; DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE; DmaHandle.Init.MemInc = DMA_MINC_ENABLE; DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; DmaHandle.Init.Mode = DMA_CIRCULAR; DmaHandle.Init.Priority = DMA_PRIORITY_HIGH; /* Deinitialize & Initialize the DMA for new transfer */ HAL_DMA_DeInit(&DmaHandle); HAL_DMA_Init(&DmaHandle); /* Associate the initialized DMA handle to the the ADC handle */ __HAL_LINKDMA(hadc, DMA_Handle, DmaHandle); /*##-4- Configure the NVIC for DMA #########################################*/ /* NVIC configuration for DMA transfer complete interrupt */ HAL_NVIC_SetPriority(ADCx_DMA_IRQn, 5, 0); HAL_NVIC_EnableIRQ(ADCx_DMA_IRQn); }
void RCC_Configuration() { #if (PREFETCH_ENABLE != 0) __HAL_FLASH_PREFETCH_BUFFER_ENABLE(); #endif __HAL_RCC_BKP_CLK_ENABLE(); __HAL_RCC_PWR_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_I2C1_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_AFIO_CLK_ENABLE(); }
/** * @brief Configure the DMA controller according to the Stream parameters * defined in main.h file * @note This function is used to : * -1- Enable DMA1 clock * -2- Select the DMA functional Parameters * -3- Select the DMA instance to be used for the transfer * -4- Select Callbacks functions called after Transfer complete and Transfer error interrupt detection * -5- Initialize the DMA channel * -6- Configure NVIC for DMA transfer complete/error interrupts * -7- Start the DMA transfer using the interrupt mode * @param None * @retval None */ static void DMA_Config(void) { /*## -1- Enable DMA1 clock #################################################*/ __HAL_RCC_DMA1_CLK_ENABLE(); /*##-2- Select the DMA functional Parameters ###############################*/ DmaHandle.Init.Direction = DMA_MEMORY_TO_MEMORY; /* M2M transfer mode */ DmaHandle.Init.PeriphInc = DMA_PINC_ENABLE; /* Peripheral increment mode Enable */ DmaHandle.Init.MemInc = DMA_MINC_ENABLE; /* Memory increment mode Enable */ DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* Peripheral data alignment : Word */ DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* memory data alignment : Word */ DmaHandle.Init.Mode = DMA_NORMAL; /* Normal DMA mode */ DmaHandle.Init.Priority = DMA_PRIORITY_HIGH; /* priority level : high */ /*##-3- Select the DMA instance to be used for the transfer : DMA1_Channel1 #*/ DmaHandle.Instance = DMA_INSTANCE; /*##-4- Select Callbacks functions called after Transfer complete and Transfer error */ DmaHandle.XferCpltCallback = TransferComplete; DmaHandle.XferErrorCallback = TransferError; /*##-5- Initialize the DMA channel ##########################################*/ if (HAL_DMA_Init(&DmaHandle) != HAL_OK) { /* Initialization Error */ Error_Handler(); } /*##-6- Configure NVIC for DMA transfer complete/error interrupts ##########*/ /* Set Interrupt Group Priority */ HAL_NVIC_SetPriority(DMA_INSTANCE_IRQ, 0, 0); /* Enable the DMA STREAM global Interrupt */ HAL_NVIC_EnableIRQ(DMA_INSTANCE_IRQ); /*##-7- Start the DMA transfer using the interrupt mode ####################*/ /* Configure the source, destination and buffer size DMA fields and Start DMA Channel transfer */ /* Enable All the DMA interrupts */ if (HAL_DMA_Start_IT(&DmaHandle, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK) { /* Transfer Error */ Error_Handler(); } }
void Uart2DMAInit(UART_HandleTypeDef* huart) { __HAL_RCC_DMA1_CLK_ENABLE() ; huart->hdmatx = (DMA_HandleTypeDef *)calloc(1, sizeof(DMA_HandleTypeDef)); REQUIRE(huart->hdmatx != 0); huart->hdmatx->Instance = DMA1_Channel7; huart->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH; huart->hdmatx->Init.PeriphInc = DMA_PINC_DISABLE; huart->hdmatx->Init.MemInc = DMA_MINC_ENABLE; huart->hdmatx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; huart->hdmatx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; huart->hdmatx->Init.Mode = DMA_NORMAL; huart->hdmatx->Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_Init(huart->hdmatx); huart->hdmatx->Parent = huart; HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn); }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // Determine the UART to use (UART_1, UART_2, ...) UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object SERIAL_OBJ(uart) = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(SERIAL_OBJ(uart) != (UARTName)NC); // Enable USART clock switch (SERIAL_OBJ(uart)) { case UART_1: __HAL_RCC_USART1_CLK_ENABLE(); SERIAL_OBJ(index) = 0; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA2_CLK_ENABLE(); #endif break; case UART_2: __HAL_RCC_USART2_CLK_ENABLE(); SERIAL_OBJ(index) = 1; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #if defined(USART3_BASE) case UART_3: __HAL_RCC_USART3_CLK_ENABLE(); SERIAL_OBJ(index) = 2; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART4_BASE) case UART_4: __HAL_RCC_UART4_CLK_ENABLE(); SERIAL_OBJ(index) = 3; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART5_BASE) case UART_5: __HAL_RCC_UART5_CLK_ENABLE(); SERIAL_OBJ(index) = 4; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(USART6_BASE) case UART_6: __HAL_RCC_USART6_CLK_ENABLE(); SERIAL_OBJ(index) = 5; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA2_CLK_ENABLE(); #endif break; #endif #if defined(UART7_BASE) case UART_7: __HAL_RCC_UART7_CLK_ENABLE(); SERIAL_OBJ(index) = 6; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif #if defined(UART8_BASE) case UART_8: __HAL_RCC_UART8_CLK_ENABLE(); SERIAL_OBJ(index) = 7; #if DEVICE_SERIAL_ASYNCH_DMA __HAL_RCC_DMA1_CLK_ENABLE(); #endif break; #endif } // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } // Configure UART SERIAL_OBJ(baudrate) = 9600; SERIAL_OBJ(databits) = UART_WORDLENGTH_8B; SERIAL_OBJ(stopbits) = UART_STOPBITS_1; SERIAL_OBJ(parity) = UART_PARITY_NONE; SERIAL_OBJ(pin_tx) = tx; SERIAL_OBJ(pin_rx) = rx; init_uart(obj); // For stdio management if (SERIAL_OBJ(uart) == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
/** * @brief ADC MSP Init * @param hadc : ADC handle * @retval None */ void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc) { GPIO_InitTypeDef GPIO_InitStruct; static DMA_HandleTypeDef DmaHandle; /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* Enable GPIO clock ****************************************/ __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); /* ADC1 Periph clock enable */ ADCx_CLK_ENABLE(); /* Enable DMA1 clock */ __HAL_RCC_DMA1_CLK_ENABLE(); /*##- 2- Configure peripheral GPIO #########################################*/ /* ADC Channel GPIO pin configuration */ GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_1; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_0; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_0; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_1; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_2; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /*##- 3- Configure DMA #####################################################*/ /*********************** Configure DMA parameters ***************************/ DmaHandle.Instance = DMA1_Channel1; DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY; DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE; DmaHandle.Init.MemInc = DMA_MINC_ENABLE; DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD; DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; DmaHandle.Init.Mode = DMA_CIRCULAR; DmaHandle.Init.Priority = DMA_PRIORITY_MEDIUM; /* Deinitialize & Initialize the DMA for new transfer */ HAL_DMA_DeInit(&DmaHandle); HAL_DMA_Init(&DmaHandle); /* Associate the DMA handle */ __HAL_LINKDMA(hadc, DMA_Handle, DmaHandle); /* NVIC configuration for DMA Input data interrupt */ HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1, 0); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); /* NVIC configuration for ADC interrupt */ /* Priority: high-priority */ HAL_NVIC_SetPriority(ADC1_2_IRQn, 0, 0); HAL_NVIC_EnableIRQ(ADC1_2_IRQn); }
void I2C_Init() { __HAL_RCC_I2C2_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); /* DMA1_Channel4_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 1, 4); HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn); /* DMA1_Channel5_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 1, 3); HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn); hi2c2.Instance = I2C2; hi2c2.Init.ClockSpeed = 100000; hi2c2.Init.DutyCycle = I2C_DUTYCYCLE_2; hi2c2.Init.OwnAddress1 = 0; hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c2.Init.OwnAddress2 = 0; hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; HAL_I2C_Init(&hi2c2); GPIO_InitTypeDef GPIO_InitStruct; __HAL_RCC_DMA1_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /* USER CODE BEGIN I2C2_MspInit 0 */ /* USER CODE END I2C2_MspInit 0 */ /**I2C2 GPIO Configuration PB10 ------> I2C2_SCL PB11 ------> I2C2_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __HAL_RCC_I2C2_CLK_ENABLE(); /* Peripheral DMA init*/ hdma_i2c2_rx.Instance = DMA1_Channel5; hdma_i2c2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2c2_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c2_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c2_rx.Init.Mode = DMA_NORMAL; hdma_i2c2_rx.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&hdma_i2c2_rx); __HAL_LINKDMA(&hi2c2,hdmarx,hdma_i2c2_rx); hdma_i2c2_tx.Instance = DMA1_Channel4; hdma_i2c2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_i2c2_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c2_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c2_tx.Init.Mode = DMA_NORMAL; hdma_i2c2_tx.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&hdma_i2c2_tx); __HAL_LINKDMA(&hi2c2,hdmatx,hdma_i2c2_tx); /* Peripheral interrupt init */ HAL_NVIC_SetPriority(I2C2_EV_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2C2_EV_IRQn); HAL_NVIC_SetPriority(I2C2_ER_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2C2_ER_IRQn); /* USER CODE BEGIN I2C2_MspInit 1 */ /* USER CODE END I2C2_MspInit 1 */ }
void MX_ADC1_Init(void) { ADC_MultiModeTypeDef multimode; ADC_ChannelConfTypeDef sConfig; __HAL_RCC_ADC1_CLK_ENABLE(); hadc1.Instance = ADC1; hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE; hadc1.Init.ContinuousConvMode = DISABLE; hadc1.Init.DiscontinuousConvMode = DISABLE; hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T8_TRGO; hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; hadc1.Init.NbrOfConversion = 5; HAL_ADC_Init(&hadc1); /**Enable or disable the remapping of ADC1_ETRGREG: * ADC1 External Event regular conversion is connected to TIM8 TRG0 */ __HAL_AFIO_REMAP_ADC1_ETRGREG_ENABLE(); /**Configure the ADC multi-mode */ multimode.Mode = ADC_DUALMODE_REGSIMULT; HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode); sConfig.SamplingTime = ADC_SAMPLETIME_7CYCLES_5; sConfig.Channel = ADC_CHANNEL_14; sConfig.Rank = 1; HAL_ADC_ConfigChannel(&hadc1, &sConfig); sConfig.Channel = ADC_CHANNEL_0; sConfig.Rank = 2; HAL_ADC_ConfigChannel(&hadc1, &sConfig); sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5; sConfig.Channel = ADC_CHANNEL_11; sConfig.Rank = 3; HAL_ADC_ConfigChannel(&hadc1, &sConfig); sConfig.Channel = ADC_CHANNEL_12; sConfig.Rank = 4; HAL_ADC_ConfigChannel(&hadc1, &sConfig); sConfig.Channel = ADC_CHANNEL_12; sConfig.Rank = 5; HAL_ADC_ConfigChannel(&hadc1, &sConfig); hadc1.Instance->CR2 |= ADC_CR2_DMA; __HAL_ADC_ENABLE(&hadc1); __HAL_RCC_DMA1_CLK_ENABLE(); DMA1_Channel1->CCR = 0; DMA1_Channel1->CNDTR = 5; DMA1_Channel1->CPAR = (uint32_t) & (ADC1->DR); DMA1_Channel1->CMAR = (uint32_t)&adc_buffer; DMA1_Channel1->CCR = DMA_CCR_MSIZE_1 | DMA_CCR_PSIZE_1 | DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_TCIE; DMA1_Channel1->CCR |= DMA_CCR_EN; HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); }
static int stm32_qspi_init(struct rt_qspi_device *device, struct rt_qspi_configuration *qspi_cfg) { int result = RT_EOK; unsigned int i = 1; RT_ASSERT(device != RT_NULL); RT_ASSERT(qspi_cfg != RT_NULL); struct rt_spi_configuration *cfg = &qspi_cfg->parent; struct stm32_qspi_bus *qspi_bus = device->parent.bus->parent.user_data; rt_memset(&qspi_bus->QSPI_Handler, 0, sizeof(qspi_bus->QSPI_Handler)); QSPI_HandleTypeDef QSPI_Handler_config = QSPI_BUS_CONFIG; qspi_bus->QSPI_Handler = QSPI_Handler_config; while (cfg->max_hz < HAL_RCC_GetHCLKFreq() / (i + 1)) { i++; if (i == 255) { LOG_E("QSPI init failed, QSPI frequency(%d) is too low.", cfg->max_hz); return -RT_ERROR; } } /* 80/(1+i) */ qspi_bus->QSPI_Handler.Init.ClockPrescaler = i; if (!(cfg->mode & RT_SPI_CPOL)) { /* QSPI MODE0 */ qspi_bus->QSPI_Handler.Init.ClockMode = QSPI_CLOCK_MODE_0; } else { /* QSPI MODE3 */ qspi_bus->QSPI_Handler.Init.ClockMode = QSPI_CLOCK_MODE_3; } /* flash size */ qspi_bus->QSPI_Handler.Init.FlashSize = POSITION_VAL(qspi_cfg->medium_size) - 1; result = HAL_QSPI_Init(&qspi_bus->QSPI_Handler); if (result == HAL_OK) { LOG_D("qspi init succsee!"); } else { LOG_E("qspi init failed (%d)!", result); } #ifdef BSP_QSPI_USING_DMA /* QSPI interrupts must be enabled when using the HAL_QSPI_Receive_DMA */ HAL_NVIC_SetPriority(QSPI_IRQn, 0, 0); HAL_NVIC_EnableIRQ(QSPI_IRQn); HAL_NVIC_SetPriority(QSPI_DMA_IRQ, 0, 0); HAL_NVIC_EnableIRQ(QSPI_DMA_IRQ); /* init QSPI DMA */ if(QSPI_DMA_RCC == RCC_AHB1ENR_DMA1EN) { __HAL_RCC_DMA1_CLK_ENABLE(); } else { __HAL_RCC_DMA2_CLK_ENABLE(); } HAL_DMA_DeInit(qspi_bus->QSPI_Handler.hdma); DMA_HandleTypeDef hdma_quadspi_config = QSPI_DMA_CONFIG; qspi_bus->hdma_quadspi = hdma_quadspi_config; if (HAL_DMA_Init(&qspi_bus->hdma_quadspi) != HAL_OK) { LOG_E("qspi dma init failed (%d)!", result); } __HAL_LINKDMA(&qspi_bus->QSPI_Handler, hdma, qspi_bus->hdma_quadspi); #endif /* BSP_QSPI_USING_DMA */ return result; }
static int uart_init_peripheral(void) { __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_DMA1_CLK_ENABLE(); UARThandle.Instance = UART_INSTANCE; UARThandle.Init.BaudRate = UART_BAUDRATE; UARThandle.Init.WordLength = UART_WORDLENGTH_8B; UARThandle.Init.StopBits = UART_STOPBITS_1; UARThandle.Init.Parity = UART_PARITY_NONE; UARThandle.Init.HwFlowCtl = UART_HWCONTROL_NONE; UARThandle.Init.OverSampling = UART_OVERSAMPLING_8; UARThandle.Init.Mode = UART_MODE_TX_RX; DMAhandle_TX.Instance = DMA1_Stream6; DMAhandle_TX.Init.Channel = DMA_CHANNEL_4; DMAhandle_TX.Init.Direction = DMA_MEMORY_TO_PERIPH; DMAhandle_TX.Init.FIFOMode = DMA_FIFOMODE_DISABLE; DMAhandle_TX.Init.MemBurst = DMA_MBURST_SINGLE; DMAhandle_TX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; DMAhandle_TX.Init.MemInc = DMA_MINC_ENABLE; DMAhandle_TX.Init.Mode = DMA_NORMAL; DMAhandle_TX.Init.PeriphBurst = DMA_PBURST_SINGLE; DMAhandle_TX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; DMAhandle_TX.Init.PeriphInc = DMA_PINC_DISABLE; DMAhandle_TX.Init.Priority = DMA_PRIORITY_LOW; DMAhandle_RX = DMAhandle_TX; DMAhandle_RX.Instance = DMA1_Stream5; DMAhandle_RX.Init.Channel = DMA_CHANNEL_4; DMAhandle_RX.Init.Direction = DMA_PERIPH_TO_MEMORY; DMAhandle_RX.Init.Mode = DMA_CIRCULAR; UARThandle.hdmatx = &DMAhandle_TX; UARThandle.hdmarx = &DMAhandle_RX; HAL_UART_DeInit(&UARThandle); HAL_UART_Init(&UARThandle); UART_INSTANCE->BRR = (2u << 4u) | (5u); /* Baudrate = 2000000 with SYSCLK=168MHz, * HAL is not very good at figuring this number out... */ HAL_DMA_DeInit(&DMAhandle_TX); HAL_DMA_Init(&DMAhandle_TX); HAL_DMA_DeInit(&DMAhandle_RX); HAL_DMA_Init(&DMAhandle_RX); NVIC_SetPriority(DMA1_Stream6_IRQn, UART_DMA_TX_IRQ_PRIO); HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn); NVIC_SetPriority(DMA1_Stream5_IRQn, UART_DMA_RX_IRQ_PRIO); HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn); /* Use uart data register as peripheral destination for TX */ DMAhandle_TX.Instance->PAR = (uint32_t) &(UARThandle.Instance->DR); /* Set source and destination address and buffer length */ DMAhandle_RX.Instance->NDTR = RX_BUF_LEN; DMAhandle_RX.Instance->PAR = (uint32_t) &(UARThandle.Instance->DR); DMAhandle_RX.Instance->M0AR = (uint32_t) dma_buffer_rx; /* Enable UART as DMA enabled receiver */ UARThandle.Instance->CR3 |= USART_CR3_DMAR; /* Enable transfer complete interrupt */ __HAL_DMA_ENABLE_IT(&DMAhandle_RX, DMA_IT_TC); __HAL_DMA_ENABLE(&DMAhandle_RX); return 0; }
void UART_Control_Init() { GPIO_InitTypeDef GPIO_InitStruct; __HAL_RCC_USART2_CLK_ENABLE(); /* DMA1_Channel6_IRQn interrupt configuration */ //HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 5, 6); //HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn); HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 5, 6); HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn); /* DMA1_Channel7_IRQn interrupt configuration */ HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 5, 7); HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn); huart2.Instance = USART2; huart2.Init.BaudRate = CONTROL_BAUD; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; // huart2.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart2); __HAL_RCC_DMA1_CLK_ENABLE(); /* USER CODE BEGIN USART2_MspInit 0 */ __HAL_RCC_GPIOA_CLK_ENABLE(); /* USER CODE END USART2_MspInit 0 */ /* Peripheral clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); GPIO_InitStruct.Pull = GPIO_PULLUP; //GPIO_NOPULL; GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; //GPIO_MODE_AF_PP; // GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral DMA init*/ hdma_usart2_rx.Instance = DMA1_Channel6; hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart2_rx.Init.Mode = DMA_CIRCULAR; //DMA_NORMAL; hdma_usart2_rx.Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_Init(&hdma_usart2_rx); __HAL_LINKDMA(&huart2,hdmarx,hdma_usart2_rx); hdma_usart2_tx.Instance = DMA1_Channel7; hdma_usart2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart2_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart2_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart2_tx.Init.Mode = DMA_NORMAL; hdma_usart2_tx.Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_Init(&hdma_usart2_tx); __HAL_LINKDMA(&huart2,hdmatx,hdma_usart2_tx); }
void systemInit(void) { // Priority grouping should be setup before any irq prio is set. HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITY_GROUPING); // GPIO ports are always used so it makes sense to just enable the clocks to the available ports #ifdef GPIOA __HAL_RCC_GPIOA_CLK_ENABLE(); #endif #ifdef GPIOB __HAL_RCC_GPIOB_CLK_ENABLE(); #endif #ifdef GPIOC __HAL_RCC_GPIOC_CLK_ENABLE(); #endif #ifdef GPIOD __HAL_RCC_GPIOD_CLK_ENABLE(); #endif #ifdef GPIOE __HAL_RCC_GPIOE_CLK_ENABLE(); #endif #ifdef GPIOF __HAL_RCC_GPIOF_CLK_ENABLE(); #endif // It makes it all lot easier if we just enable to DMA clocks, the additional idle current is neglectable #ifdef DMA1 __HAL_RCC_DMA1_CLK_ENABLE(); #endif #ifdef DMA2 __HAL_RCC_DMA2_CLK_ENABLE(); #endif /* Select SysClk as source of USART1 clocks */ RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit; RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1; RCC_PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK; HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit); // Init clocks of used peripherals #ifdef USE_USART1 __HAL_RCC_USART1_CLK_ENABLE(); #endif #ifdef USE_USART2 __HAL_RCC_USART2_CLK_ENABLE(); #endif #ifdef USE_USART3 __HAL_RCC_USART3_CLK_ENABLE(); #endif #ifdef USE_USART4 __HAL_RCC_UART4_CLK_ENABLE(); #endif #ifdef USE_USART5 __HAL_RCC_UART5_CLK_ENABLE(); #endif #ifdef USE_USART6 __HAL_RCC_USART6_CLK_ENABLE(); #endif #ifdef USE_USART7 __HAL_RCC_UART7_CLK_ENABLE(); #endif #ifdef USE_USART8 __HAL_RCC_UART8_CLK_ENABLE(); #endif }