/**
* Enable DMA controller clock
* Configure DMA for memory to memory transfers
* hdma_memtomem_dma2_stream0
*/
static void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_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_DISABLE;
hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_ENABLE;
hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL;
hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_LOW;
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_INC4;
hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_INC4;
if (HAL_DMA_Init(&hdma_memtomem_dma2_stream0) != HAL_OK)
{
Error_Handler();
}
/* DMA interrupt init */
/* DMA2_Stream0_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}
/**
* @brief Configure the DMA controller according to the Stream parameters
* defined in main.h file
* @note This function is used to :
* -1- Enable DMA2 clock
* -2- Select the DMA functional Parameters
* -3- Select the DMA instance to be used for the transfer
* -4- Select Callbacks functions called after Transfer complete and
Transfer error interrupt detection
* -5- Initialize the DMA stream
* -6- Configure NVIC for DMA transfer complete/error interrupts
* -7- Start the DMA transfer using the interrupt mode
* @param None
* @retval None
*/
static void DMA_Config(void)
{
/*## -1- Enable DMA2 clock #################################################*/
__HAL_RCC_DMA2_CLK_ENABLE();
/*##-2- Select the DMA functional Parameters ###############################*/
DmaHandle.Init.Channel = DMA_CHANNEL; /* DMA_CHANNEL_0 */
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 */
DmaHandle.Init.FIFOMode = DMA_FIFOMODE_DISABLE; /* FIFO mode disabled */
DmaHandle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
DmaHandle.Init.MemBurst = DMA_MBURST_SINGLE; /* Memory burst */
DmaHandle.Init.PeriphBurst = DMA_PBURST_SINGLE; /* Peripheral burst */
/*##-3- Select the DMA instance to be used for the transfer : DMA2_Stream0 #*/
DmaHandle.Instance = DMA_STREAM;
/*##-4- Select Callbacks functions called after Transfer complete and Transfer error */
DmaHandle.XferCpltCallback = TransferComplete;
DmaHandle.XferErrorCallback = TransferError;
/*##-5- Initialize the DMA stream ##########################################*/
if(HAL_DMA_Init(&DmaHandle) != HAL_OK)
{
/* Turn LED3/LED4 on: in case of Initialization Error */
BSP_LED_On(LED3);
BSP_LED_On(LED4);
while(1)
{
}
}
/*##-6- Configure NVIC for DMA transfer complete/error interrupts ##########*/
HAL_NVIC_SetPriority(DMA_STREAM_IRQ, 0, 0);
HAL_NVIC_EnableIRQ(DMA_STREAM_IRQ);
/*##-7- Start the DMA transfer using the interrupt mode ####################*/
/* Configure the source, destination and buffer size DMA fields and Start DMA Stream transfer */
/* Enable All the DMA interrupts */
if(HAL_DMA_Start_IT(&DmaHandle, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/* Turn LED3/LED4 on: Transfer error */
BSP_LED_On(LED3);
BSP_LED_On(LED4);
while(1)
{
}
}
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_CLK_ENABLE();
/* DMA interrupt init */
/* DMA2_Stream1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
}
void HAL_USART_MspInit(USART_HandleTypeDef *husart) {
if (husart->Instance == USART1) {
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
initGPIO_USART1_Trace();
} else if (husart->Instance == USART2) {
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
initGPIO_USART2();
}
}
//******************************************************************************
// board_adc_enable_clock
//
// Enable the clock for a specifc ADC module.
// Requires the caller previously invoked board_adc_get_status_block()
//
// Note that ADC_AUTO_MODULE = 0, so it is the first entry in the lookup table
//******************************************************************************
void board_adc_enable_clocks (int module_id)
{
__HAL_RCC_ADC1_CLK_ENABLE(); // Enable ADC1 Periph clock
__HAL_RCC_ADC2_CLK_ENABLE(); // Enable ADC2 Periph clock
__HAL_RCC_ADC3_CLK_ENABLE(); // Enable ADC3 Periph clock
// Enable the ADC module's associated DMA module's clocks
__HAL_RCC_DMA2_CLK_ENABLE(); // Enable DMA2 clock F4 / F7
////__DMA1_CLK_ENABLE(); // Enable F3_03/L0/F0 DMA clock - F0 has only
// 1 DMA unit, except F09x which has 2 and F3_34 has 3
}
void PX4_UART_MspInit(UART_HandleTypeDef *huart)
{
//配置PX4 TX,RX GPIOA_PIN9 GPIOA_10
GPIO_InitTypeDef GPIO_PX4;
/* Enable the GPIO_A clock */
__GPIOA_CLK_ENABLE();//打开端口时钟
__USART1_CLK_ENABLE();//打开串口时钟
GPIO_PX4.Pin = GPIO_PIN_9; //GPIOA Pin9 RX
GPIO_PX4.Mode = GPIO_MODE_AF_PP; //作为选择功能
GPIO_PX4.Pull = GPIO_PULLUP; //上拉
GPIO_PX4.Speed = GPIO_SPEED_HIGH; //高速
GPIO_PX4.Alternate=GPIO_AF7_USART1; //选择功能 作为USART功能
HAL_GPIO_Init(GPIOA, &GPIO_PX4);
GPIO_PX4.Pin=GPIO_PIN_10; //配置RX口
HAL_GPIO_Init(GPIOA, &GPIO_PX4);
HAL_NVIC_SetPriority(USART1_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(USART1_IRQn);
#if 0 /*##-3- Configure the DMA ##################################################*/
/* Configure the DMA handler for reception process */
__HAL_RCC_DMA2_CLK_ENABLE(); //打开DMA时钟
PX4DMA_Receive.Instance = DMA2_Stream2; //数据流2
PX4DMA_Receive.Init.Channel = DMA_CHANNEL_4; //通道4
PX4DMA_Receive.Init.Direction = DMA_PERIPH_TO_MEMORY; //外设到内存
PX4DMA_Receive.Init.PeriphInc = DMA_PINC_DISABLE; //外设地址是否增 不增加
PX4DMA_Receive.Init.MemInc = DMA_MINC_ENABLE; //内存地址是否增 递增
PX4DMA_Receive.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设字节对其
PX4DMA_Receive.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //内存字节对其
PX4DMA_Receive.Init.Mode = DMA_NORMAL; //DMA 模式 正常模式
PX4DMA_Receive.Init.Priority = DMA_PRIORITY_HIGH; //优先级
// PX4DMA_Receive.Init.FIFOMode = DMA_FIFOMODE_DISABLE; //是否使用FIFO 否
// PX4DMA_Receive.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL; //指定FIFO的阈值水平
// PX4DMA_Receive.Init.MemBurst = DMA_MBURST_SINGLE; //指定的Burst转移配置内存传输
// PX4DMA_Receive.Init.PeriphBurst = DMA_PBURST_SINGLE; //指定的Burst转移配置外围转移
HAL_DMA_Init(&PX4DMA_Receive);//DMA初始化
//*****************************************************自配DMA模式 start******************//
/* Set the UART DMA transfer complete callback */
// PX4_UartHandle->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
/* Enable the DMA channel */
//HAL_DMA_Start_IT(PX4_UartHandle->hdmarx, (uint32_t)&PX4_UartHandle->Instance->RDR, *(uint32_t*)PX4_Buf, PX4_GetBuf);
//*****************************************************自配DMA模式 start******************//
/* Associate the initialized DMA handle to the the UART handle */
__HAL_LINKDMA(&PX4_UartHandle, hdmarx, PX4DMA_Receive);
//DMA 中断
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 0, 0);//设置优先级
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);//使能DMA2中断
#endif
}
//******************************************************************************
// board_adc_enable_clock
//
// Enable the clock for a specifc ADC module.
// Requires the caller previously invoked board_adc_get_status_block()
//
// Note that ADC_AUTO_MODULE = 0, so it is the first entry in the lookup table
//******************************************************************************
void board_adc_enable_clocks (int module_id)
{
// ON L4 / F7, default module must be ADC 3 !!!
if (module_id == 1)
__HAL_RCC_ADC1_CLK_ENABLE(); // Enable ADC Periph clock
else if (module_id == 2)
__HAL_RCC_ADC2_CLK_ENABLE();
else if (module_id == 3 || module_id == ADCMD)
__HAL_RCC_ADC3_CLK_ENABLE(); // F7 46G just supports 3 ADCs
// Enable the ADC module's associated DMA module's clocks
__HAL_RCC_DMA2_CLK_ENABLE(); // Enable DMA2 clock F4/F7
__DMA1_CLK_ENABLE(); // Enable F3_03/L0/F0 DMA clock - F0 has only
// 1 DMA unit, except F09x which has 2 and F3_34 has 3
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
HAL_NVIC_SetPriority(DMA2_Channel2_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Channel2_IRQn);
}
static void
stm32f4_adc_dma_init(ADC_HandleTypeDef* hadc)
{
DMA_HandleTypeDef *hdma;
assert(hadc);
hdma = hadc->DMA_Handle;
stm32f4_adc_clk_enable(hadc);
__HAL_RCC_DMA2_CLK_ENABLE();
HAL_DMA_Init(hdma);
dma_handle[stm32f4_resolve_dma_handle_idx(hdma)] = hdma;
NVIC_SetPriority(stm32f4_resolve_adc_dma_irq(hdma),
NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 0, 0));
NVIC_SetVector(stm32f4_resolve_adc_dma_irq(hdma),
stm32f4_resolve_adc_dma_irq_handler(hdma));
NVIC_EnableIRQ(stm32f4_resolve_adc_dma_irq(hdma));
}
/**
* Initialize the UART to communicate with the Skywire modem.
*/
void
skywire_init() {
/* Configure the UART for the Skywire modem. */
__HAL_RCC_USART1_CLK_ENABLE();
skywire.huart.Instance = USART1;
skywire.huart.State = HAL_UART_STATE_RESET;
skywire.huart.Init.BaudRate = 115200;
skywire.huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
skywire.huart.Init.Mode = UART_MODE_TX_RX;
skywire.huart.Init.WordLength = UART_WORDLENGTH_8B;
skywire.huart.Init.Parity = UART_PARITY_NONE;
skywire.huart.Init.StopBits = UART_STOPBITS_1;
skywire.huart.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&skywire.huart);
/* Configure a DMA channel to service the UART. */
__HAL_RCC_DMA2_CLK_ENABLE();
skywire.hdma.Instance = DMA2_Stream5;
skywire.hdma.State = HAL_DMA_STATE_RESET;
skywire.hdma.Init.Channel = DMA_CHANNEL_4;
skywire.hdma.Init.Direction = DMA_PERIPH_TO_MEMORY;
skywire.hdma.Init.PeriphInc = DMA_PINC_DISABLE;
skywire.hdma.Init.MemInc = DMA_MINC_ENABLE;
skywire.hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
skywire.hdma.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
skywire.hdma.Init.Mode = DMA_CIRCULAR;
skywire.hdma.Init.Priority = DMA_PRIORITY_LOW;
skywire.hdma.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
skywire.hdma.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
skywire.hdma.Init.MemBurst = DMA_MBURST_SINGLE;
skywire.hdma.Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(&skywire.hdma);
__HAL_LINKDMA(&skywire.huart, hdmarx, skywire.hdma);
/* Start the receive process. */
HAL_UART_Receive_DMA(&skywire.huart, skywire.rx_buffer, skywire.rx_length);
}
/**
* @brief Initializes the DCMI MSP.
* @param hdcmi: HDMI handle
* @retval None
*/
__weak void BSP_CAMERA_MspInit(DCMI_HandleTypeDef *hdcmi, void *Params)
{
static DMA_HandleTypeDef hdma_eval;
GPIO_InitTypeDef gpio_init_structure;
/*** Enable peripherals and GPIO clocks ***/
/* Enable DCMI clock */
__HAL_RCC_DCMI_CLK_ENABLE();
/* Enable DMA2 clock */
__HAL_RCC_DMA2_CLK_ENABLE();
/* Enable GPIO clocks */
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
/*** Configure the GPIO ***/
/* Configure DCMI GPIO as alternate function */
gpio_init_structure.Pin = GPIO_PIN_4 | 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);
#if !defined(USE_STM32446E_EVAL_REVA)
gpio_init_structure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9;
#else
gpio_init_structure.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9;
#endif // !USE_STM32446E_EVAL_REVA
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);
#if !defined(USE_STM32446E_EVAL_REVA)
gpio_init_structure.Pin = GPIO_PIN_2 | GPIO_PIN_6;
#else
gpio_init_structure.Pin = GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_6;
#endif // !USE_STM32446E_EVAL_REVA
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);
/*** 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);
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_ADC3_Init();
MX_I2C1_Init();
MX_SPI1_Init();
MX_SPI2_Init();
MX_TIM1_Init();
MX_TIM2_Init();
MX_USB_OTG_FS_PCD_Init();
/* USER CODE BEGIN 2 */
TIM1->CCR1 = 0x300;
TIM1->CCR2 = 0x300;
TIM2->CCR2 = 0x60;
// Настройка deathTime
pwm.init();
/* bugfix */ pwmDeathTime.setValue(10);
htim1.Instance->BDTR &= ~TIM_BDTR_DTG;
htim1.Instance->BDTR |= pwm.computeDeathTime(pwmDeathTime.getValueFlt());
HAL_TIM_Base_Start(&htim1);
// Выходной сигнал для ацп
HAL_TIM_OC_Start(&htim2, TIM_CHANNEL_2);
// Выходной сигнал для ацп
HAL_TIM_OC_Start(&htim1, TIM_CHANNEL_3);
// HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);
// HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_2);
// pwm.start();
// HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_1);
// HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_2);
__HAL_RCC_DMA2_CLK_ENABLE();
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc1.getBufer(), adc1.getBuferSize());
HAL_ADC_Start_DMA(&hadc3, (uint32_t*)adc3.getBufer(), adc3.getBuferSize());
//------------------------------------------------------------------------------
// Низкоуровневая инициализация
//------------------------------------------------------------------------------
// Разрешение выходов буферов
GPIOC->BSRR = BIT_14;
// Инициализация SPI портов
//------------------------------------------------------------------------------
// Агрегация объектов
// Определяется только при инициализации программы
//------------------------------------------------------------------------------
mainMenu.addObserver( &menuEngine ); // Объект menuEngine подписался на рассылку событий, объявленных в IControlCommands
//------------------------------------------------------------------------------
// Начальные условия
//------------------------------------------------------------------------------
menuEngine.setMenuValue("");
// Затычка на время отсутствия FRAM. Инициализация float данных
vICalibrating.setValue(vICalibrating.getValue());
vUDcBusCodeUCal.setValue(vUDcBusCodeUCal.getValue());
vUDcBusCodeZero.setValue(vUDcBusCodeZero.getValue());
vIChargeCodeICal.setValue(vIChargeCodeICal.getValue());
vUChargeCodeUCal.setValue(vUChargeCodeUCal.getValue());
vIChargeCodeZero.setValue(vIChargeCodeZero.getValue());
vUChargeCodeZero.setValue(vUChargeCodeZero.getValue());
vDcBusLoadVoltageDifferent.setValue(vDcBusLoadVoltageDifferent.getValue());
/* USER CODE END 2 */
/* Call init function for freertos objects (in freertos.c) */
MX_FREERTOS_Init();
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
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 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 */
__HAL_RCC_SAI2_CLK_ENABLE();
/* Configure GPIOs used for SAI2 */
AUDIO_SAIx_MCLK_ENABLE();
AUDIO_SAIx_SCK_ENABLE();
AUDIO_SAIx_FS_ENABLE();
AUDIO_SAIx_SD_ENABLE();
GPIO_Init.Mode = GPIO_MODE_AF_PP;
GPIO_Init.Pull = GPIO_NOPULL;
GPIO_Init.Speed = GPIO_SPEED_HIGH;
GPIO_Init.Alternate = AUDIO_SAIx_FS_AF;
GPIO_Init.Pin = AUDIO_SAIx_FS_PIN;
HAL_GPIO_Init(AUDIO_SAIx_FS_GPIO_PORT, &GPIO_Init);
GPIO_Init.Alternate = AUDIO_SAIx_SCK_AF;
GPIO_Init.Pin = AUDIO_SAIx_SCK_PIN;
HAL_GPIO_Init(AUDIO_SAIx_SCK_GPIO_PORT, &GPIO_Init);
GPIO_Init.Alternate = AUDIO_SAIx_SD_AF;
GPIO_Init.Pin = AUDIO_SAIx_SD_PIN;
HAL_GPIO_Init(AUDIO_SAIx_SD_GPIO_PORT, &GPIO_Init);
GPIO_Init.Alternate = AUDIO_SAIx_MCLK_AF;
GPIO_Init.Pin = AUDIO_SAIx_MCLK_PIN;
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 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);
}
inline void JOYSTICK_ADC_DMA_CLK_ENABLE()
{
__HAL_RCC_DMA2_CLK_ENABLE()
;
}
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;
}
void enableGPIOPowerUsageAndNoiseReductions(void)
{
// AHB1
__HAL_RCC_BKPSRAM_CLK_ENABLE();
__HAL_RCC_DTCMRAMEN_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__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();
#ifndef STM32F722xx
__HAL_RCC_DMA2D_CLK_ENABLE();
__HAL_RCC_GPIOJ_CLK_ENABLE();
__HAL_RCC_GPIOK_CLK_ENABLE();
#endif
//APB1
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_TIM5_CLK_ENABLE();
__HAL_RCC_TIM6_CLK_ENABLE();
__HAL_RCC_TIM7_CLK_ENABLE();
__HAL_RCC_TIM12_CLK_ENABLE();
__HAL_RCC_TIM13_CLK_ENABLE();
__HAL_RCC_TIM14_CLK_ENABLE();
__HAL_RCC_LPTIM1_CLK_ENABLE();
__HAL_RCC_SPI2_CLK_ENABLE();
__HAL_RCC_SPI3_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_UART5_CLK_ENABLE();
__HAL_RCC_I2C1_CLK_ENABLE();
__HAL_RCC_I2C2_CLK_ENABLE();
__HAL_RCC_I2C3_CLK_ENABLE();
__HAL_RCC_CAN1_CLK_ENABLE();
__HAL_RCC_DAC_CLK_ENABLE();
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_UART8_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_I2C4_CLK_ENABLE();
__HAL_RCC_CAN2_CLK_ENABLE();
__HAL_RCC_CEC_CLK_ENABLE();
#endif
//APB2
__HAL_RCC_TIM1_CLK_ENABLE();
__HAL_RCC_TIM8_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_ADC2_CLK_ENABLE();
__HAL_RCC_ADC3_CLK_ENABLE();
__HAL_RCC_SDMMC1_CLK_ENABLE();
__HAL_RCC_SPI1_CLK_ENABLE();
__HAL_RCC_SPI4_CLK_ENABLE();
__HAL_RCC_TIM9_CLK_ENABLE();
__HAL_RCC_TIM10_CLK_ENABLE();
__HAL_RCC_TIM11_CLK_ENABLE();
__HAL_RCC_SPI5_CLK_ENABLE();
__HAL_RCC_SAI1_CLK_ENABLE();
__HAL_RCC_SAI2_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_SPI6_CLK_ENABLE();
#endif
//
// GPIO_InitTypeDef GPIO_InitStructure;
// GPIO_StructInit(&GPIO_InitStructure);
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // default is un-pulled input
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_11 | GPIO_Pin_12); // leave USB D+/D- alone
//
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_13 | GPIO_Pin_14); // leave JTAG pins alone
// GPIO_Init(GPIOA, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOB, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOC, &GPIO_InitStructure);
// GPIO_Init(GPIOD, &GPIO_InitStructure);
// GPIO_Init(GPIOE, &GPIO_InitStructure);
}
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
}
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));
}
}
//{{{
uint8_t SD_Init() {
//{{{ sdDetect init
SD_DETECT_GPIO_CLK_ENABLE();
GPIO_InitTypeDef gpio_init_structure;
gpio_init_structure.Pin = SD_DETECT_PIN;
gpio_init_structure.Mode = GPIO_MODE_INPUT;
gpio_init_structure.Pull = GPIO_PULLUP;
gpio_init_structure.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init (SD_DETECT_GPIO_PORT, &gpio_init_structure);
//}}}
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;
__HAL_RCC_DMA2_CLK_ENABLE();
// sd interrupt
#ifdef STM32F746G_DISCO
uSdHandle.Instance = SDMMC1;
__HAL_RCC_SDMMC1_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
//{{{ gpio init
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;
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);
gpio_init_structure.Pin = GPIO_PIN_2;
HAL_GPIO_Init (GPIOD, &gpio_init_structure);
//}}}
//{{{ DMA rx parameters
dma_rx_handle.Instance = DMA2_Stream3;
dma_rx_handle.Init.Channel = DMA_CHANNEL_4;
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;
__HAL_LINKDMA (&uSdHandle, hdmarx, dma_rx_handle);
HAL_DMA_DeInit (&dma_rx_handle);
HAL_DMA_Init (&dma_rx_handle);
//}}}
//{{{ DMA tx parameters
dma_tx_handle.Instance = DMA2_Stream6;
dma_tx_handle.Init.Channel = DMA_CHANNEL_4;
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;
__HAL_LINKDMA (&uSdHandle, hdmatx, dma_tx_handle);
HAL_DMA_DeInit (&dma_tx_handle);
HAL_DMA_Init (&dma_tx_handle);
//}}}
HAL_NVIC_SetPriority (SDMMC1_IRQn, 5, 0);
HAL_NVIC_EnableIRQ (SDMMC1_IRQn);
HAL_NVIC_SetPriority (DMA2_Stream3_IRQn, 6, 0); // f for 769
HAL_NVIC_EnableIRQ (DMA2_Stream3_IRQn);
HAL_NVIC_SetPriority (DMA2_Stream6_IRQn, 6, 0); // f for 769
HAL_NVIC_EnableIRQ (DMA2_Stream6_IRQn);
#else
uSdHandle.Instance = SDMMC2;
__HAL_RCC_SDMMC2_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
//{{{ gpio init
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;
gpio_init_structure.Pin = GPIO_PIN_3 | GPIO_PIN_4;
HAL_GPIO_Init (GPIOB, &gpio_init_structure);
gpio_init_structure.Alternate = GPIO_AF11_SDMMC2;
gpio_init_structure.Pin = GPIO_PIN_6 | GPIO_PIN_7;
HAL_GPIO_Init (GPIOD, &gpio_init_structure);
gpio_init_structure.Pin = GPIO_PIN_9 | GPIO_PIN_10;
HAL_GPIO_Init (GPIOG, &gpio_init_structure);
//}}}
//{{{ DMA rx parameters
dma_rx_handle.Instance = DMA2_Stream0;
dma_rx_handle.Init.Channel = DMA_CHANNEL_11;
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;
__HAL_LINKDMA (&uSdHandle, hdmarx, dma_rx_handle);
HAL_DMA_DeInit (&dma_rx_handle);
HAL_DMA_Init (&dma_rx_handle);
//}}}
//{{{ DMA tx parameters
dma_tx_handle.Instance = DMA2_Stream5;
dma_tx_handle.Init.Channel = DMA_CHANNEL_11;
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;
__HAL_LINKDMA (&uSdHandle, hdmatx, dma_tx_handle);
HAL_DMA_DeInit (&dma_tx_handle);
HAL_DMA_Init (&dma_tx_handle);
//}}}
HAL_NVIC_SetPriority (SDMMC2_IRQn, 0x5, 0); //e
HAL_NVIC_EnableIRQ (SDMMC2_IRQn);
HAL_NVIC_SetPriority (DMA2_Stream0_IRQn, 0x6, 0); //f
HAL_NVIC_EnableIRQ (DMA2_Stream0_IRQn);
HAL_NVIC_SetPriority (DMA2_Stream5_IRQn, 0x6, 0); // f
HAL_NVIC_EnableIRQ (DMA2_Stream5_IRQn);
#endif
// HAL SD initialization
if (HAL_SD_Init (&uSdHandle, &uSdCardInfo) != SD_OK)
return MSD_ERROR;
if (HAL_SD_WideBusOperation_Config (&uSdHandle, SDMMC_BUS_WIDE_4B) != SD_OK)
return MSD_ERROR;
if (HAL_SD_HighSpeed (&uSdHandle) != SD_OK)
return MSD_ERROR;
//osMutexDef (sdMutex);
//mSdMutex = osMutexCreate (osMutex (sdMutex));
mReadCache = (uint8_t*)pvPortMalloc (512 * mReadCacheSize);
return MSD_OK;
}
