|
|
STM32H750VBT6 前6个uart 都能正常通讯，UART7 和 UART8 不能通讯，实在找不出原因了，请群里的高手们指点一二 ！相关代码如下：
时钟初始化：
void SystemClock_Init(uint8_t Fosc)
{
RCC_ClkInitTypeDef RCC_ClkInitStruct;
RCC_OscInitTypeDef RCC_OscInitStruct;
HAL_StatusTypeDef ret = HAL_OK;
/*!< Supply configuration update enable */
MODIFY_REG(PWR->CR3, PWR_CR3_SCUEN, 0);
/* The voltage scaling allows optimizing the power consumption when the device is
clocked below the maximum system frequency, to update the voltage scaling value
regarding system frequency refer to product datasheet. */
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
while ((PWR->D3CR & (PWR_D3CR_VOSRDY)) != PWR_D3CR_VOSRDY) {}
/* Enable D2 domain SRAM3 Clock (0x30040000 AXI)*/
__HAL_RCC_D2SRAM3_CLK_ENABLE();
/* Enable HSE Oscillator and activate PLL with HSE as source */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSIState = RCC_HSI_OFF;
RCC_OscInitStruct.CSIState = RCC_CSI_OFF;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
if(Fosc == 25) //25MHz
{
RCC_OscInitStruct.PLL.PLLM = 5;
RCC_OscInitStruct.PLL.PLLN = 160;
}
else if(Fosc == 8) //8MHz
{
RCC_OscInitStruct.PLL.PLLM = 2;
RCC_OscInitStruct.PLL.PLLN = 200;
}
RCC_OscInitStruct.PLL.PLLP = 2;
RCC_OscInitStruct.PLL.PLLR = 2;
RCC_OscInitStruct.PLL.PLLQ = 4;
RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;
ret = HAL_RCC_OscConfig(&RCC_OscInitStruct);
if(ret != HAL_OK)
{
while(1) { ; }
}
/* Select PLL as system clock source and configure bus clocks dividers */
RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_D1PCLK1
| RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_D3PCLK1);
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
ret = HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);
if(ret != HAL_OK)
{
while(1) { ; }
}
/*activate CSI clock mondatory for I/O Compensation Cell*/
__HAL_RCC_CSI_ENABLE() ;
/* Enable SYSCFG clock mondatory for I/O Compensation Cell */
__HAL_RCC_SYSCFG_CLK_ENABLE() ;
/* Enables the I/O Compensation Cell */
HAL_EnableCompensationCell();
}
#define UART_LSR_RDR (1<<5) //接收完成标志
#define UART_LSR_THRE (1<<6) //发送完成标志
#define SEND_BUF1 (USART1->TDR)
#define RECV_BUF1 (USART1->RDR)
#define USART1_SR (USART1->ISR)
#define SEND_BUF2 (USART2->TDR)
#define RECV_BUF2 (USART2->RDR)
#define USART2_SR (USART2->ISR)
#define SEND_BUF3 (USART3->TDR)
#define RECV_BUF3 (USART3->RDR)
#define USART3_SR (USART3->ISR)
#define SEND_BUF6 (USART6->TDR)
#define RECV_BUF6 (USART6->RDR)
#define UART6_SR (USART6->ISR)
#define SEND_BUF7 (UART7->TDR)
#define RECV_BUF7 (UART7->RDR)
#define UART7_SR (UART7->ISR)
#define SEND_BUF8 (UART8->TDR)
#define RECV_BUF8 (UART8->RDR)
#define UART8_SR (UART8->ISR)
#define SEND_BUF4 (UART4->TDR)
#define RECV_BUF4 (UART4->RDR)
#define UART4_SR (UART4->ISR)
#define SEND_BUF5 (UART5->TDR)
#define RECV_BUF5 (UART5->RDR)
#define UART5_SR (UART5->ISR)
#define LP_SEND_BUF1 (LPUART1->TDR)
#define LP_RECV_BUF1 (LPUART1->RDR)
#define LP_UART1_SR (LPUART1->ISR)
typedef struct
{
void (*U1TXOver)(void); //UART1 发送完成
void (*U1RXOperation)(unsigned char RxData); //UART1 接收回调
void (*U2TXOver)(void);
void (*U2RXOperation)(unsigned char RxData); //UART2 接收回调
void (*U3TXOver)(void);
void (*U3RXOperation)(unsigned char RxData); //UART3 接收回调
void (*U6TXOver)(void);
void (*U6RXOperation)(unsigned char RxData); //UART6 接收回调
void (*U4TXOver)(void);
void (*U4RXOperation)(unsigned char RxData); //UART4 接收回调
void (*U5TXOver)(void);
void (*U5RXOperation)(unsigned char RxData); //UART5 接收回调
void (*U7TXOver)(void);
void (*U7RXOperation)(unsigned char RxData); //UART7 接收回调
void (*U8TXOver)(void);
void (*U8RXOperation)(unsigned char RxData); //UART8 接收回调
void (*LUTXOver)(void);
void (*LURXOperation)(unsigned char RxData); //LPUART 接收回调
}_USART_ISR_;
extern _USART_ISR_ Usart_ISR;
_USART_ISR_ Usart_ISR;
UART_HandleTypeDef Uart1_Handle;
UART_HandleTypeDef Uart2_Handle;
UART_HandleTypeDef Uart3_Handle;
UART_HandleTypeDef Uart6_Handle;
UART_HandleTypeDef Uart7_Handle;
UART_HandleTypeDef Uart8_Handle;
UART_HandleTypeDef Uart4_Handle;
UART_HandleTypeDef Uart5_Handle;
void USART1_IRQHandler(void)
{
if(USART1_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U1RXOperation != NULL) Usart_ISR.U1RXOperation(RECV_BUF1);
}
HAL_UART_IRQHandler(&Uart1_Handle);
}
void USART1_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
/*
下面这个配置可以注释掉，预留下来是为了方便以后选择其它时钟使用
默认情况下，USART1和USART6选择的PCLK2，时钟100MHz。
USART2，USART3，UART4，UART5，UART6，UART7和UART8选择的时钟是PLCK1，时钟100MHz。
*/
RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART16;
RCC_PeriphClkInit.Usart16ClockSelection = RCC_USART16CLKSOURCE_D2PCLK2;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);
RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit2;
RCC_PeriphClkInit2.PeriphClockSelection = RCC_PERIPHCLK_USART234578;
RCC_PeriphClkInit2.Usart234578ClockSelection = RCC_USART234578CLKSOURCE_D2PCLK1;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit2);
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U1TXOver = Tx_Over; //发送完成回调
Usart_ISR.U1RXOperation = RxFunction; //接收数据函数
__GPIOA_CLK_ENABLE(); //使能GPIOA时钟
__GPIOB_CLK_ENABLE(); //使能GPIOB时钟
__GPIOC_CLK_ENABLE(); //使能GPIOA时钟
__GPIOD_CLK_ENABLE(); //使能GPIOB时钟
__GPIOE_CLK_ENABLE(); //使能GPIOA时钟
__USART1_CLK_ENABLE(); //
__USART2_CLK_ENABLE();
__USART3_CLK_ENABLE();
__USART4_CLK_ENABLE();
__USART5_CLK_ENABLE();
__USART6_CLK_ENABLE();
__USART7_CLK_ENABLE();
__USART8_CLK_ENABLE();
//USART1端口配置
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //快速
GPIO_InitStruct.Pull = GPIO_PULLUP; //上拉
GPIO_InitStruct.Alternate = GPIO_AF7_USART1; //复用功能
GPIO_InitStruct.Pin = GPIO_PIN_9; //UASRT1对应IO口PA9 TX
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; //复用推挽模式
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); //初始化PA9
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; //快速
GPIO_InitStruct.Pull = GPIO_PULLUP; //上拉
GPIO_InitStruct.Alternate = GPIO_AF4_USART1; //复用功能
GPIO_InitStruct.Pin = GPIO_PIN_15; //UASRT1对应IO口PB15 RX
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;; //复用推挽模式
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); //初始化PB15 RX
//------------------------
//USART1 初始化设置
Uart1_Handle.Instance = USART1; //串口1
Uart1_Handle.Init.BaudRate = BPS; //波特率设置
Uart1_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart1_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart1_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart1_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart1_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart1_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart1_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart1_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart1_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(USART1_IRQn, 4, 1);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}
void USART1_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart1_Handle, (uint8_t*)buff, Size);
}
//重定义fputc函数,重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
while((USART1_SR&UART_LSR_THRE)==0); //等待发送完成
SEND_BUF1 = (u8) ch;
return ch;
}
void USART2_IRQHandler(void)
{
if(USART2_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U2RXOperation != NULL) Usart_ISR.U2RXOperation(RECV_BUF2);
}
HAL_UART_IRQHandler(&Uart2_Handle);
}
void USART2_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U2TXOver = Tx_Over; //发送完成回调
Usart_ISR.U2RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_USART2_CLK_ENABLE();
// __HAL_RCC_GPIOA_CLK_ENABLE();
// __HAL_RCC_GPIOD_CLK_ENABLE();
/**USART2 GPIO Configuration
PA3 ------> USART2_RX
PD5 ------> USART2_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
//USART2 初始化设置
Uart2_Handle.Instance = USART2; //串口1
Uart2_Handle.Init.BaudRate = BPS; //波特率设置
Uart2_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart2_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart2_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart2_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart2_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart2_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart2_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart2_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart2_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(USART2_IRQn, 4, 2);
HAL_NVIC_EnableIRQ(USART2_IRQn);
}
void USART2_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart2_Handle, (uint8_t*)buff, Size);
}
void USART3_IRQHandler(void)
{
if(USART3_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U3RXOperation != NULL) Usart_ISR.U3RXOperation(RECV_BUF3);
}
HAL_UART_IRQHandler(&Uart3_Handle);
}
void USART3_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U3TXOver = Tx_Over; //发送完成回调
Usart_ISR.U3RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_USART3_CLK_ENABLE();
// __HAL_RCC_GPIOB_CLK_ENABLE();
// __HAL_RCC_GPIOD_CLK_ENABLE();
/**USART3 GPIO Configuration
PB10 ------> USART3_TX
PD9 ------> USART3_RX
*/
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_AF7_USART3;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
GPIO_InitTypeDef GPIO_InitStruct2;
//GPIOD12初始化设置
GPIO_InitStruct2.Pin = GPIO_PIN_12; //DE
GPIO_InitStruct2.Mode = GPIO_MODE_OUTPUT_PP; //普通推挽输出模式
GPIO_InitStruct2.Speed = GPIO_SPEED_FREQ_HIGH; //高速
GPIO_InitStruct2.Pull = GPIO_PULLUP; //上拉
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct2); //初始化GPIO
//DE 高发送 低接收
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
//USART3 初始化设置
Uart3_Handle.Instance = USART3; //串口1
Uart3_Handle.Init.BaudRate = BPS; //波特率设置
Uart3_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart3_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart3_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart3_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart3_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart3_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart3_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart3_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart3_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(USART3_IRQn, 4, 3);
HAL_NVIC_EnableIRQ(USART3_IRQn);
}
void USART3_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart3_Handle, (uint8_t*)buff, Size);
}
void UART4_IRQHandler(void)
{
if(UART4_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U4RXOperation != NULL) Usart_ISR.U4RXOperation(RECV_BUF4);
}
HAL_UART_IRQHandler(&Uart4_Handle);
}
void USART4_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U4TXOver = Tx_Over; //发送完成回调
Usart_ISR.U4RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_UART4_CLK_ENABLE();
// __HAL_RCC_GPIOA_CLK_ENABLE();
/**UART4 GPIO Configuration
PA0 ------> UART4_TX
PA11 ------> UART4_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF6_UART4;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitTypeDef GPIO_InitStruct2;
//GPIOB14初始化设置
GPIO_InitStruct2.Pin = GPIO_PIN_14; //DE
GPIO_InitStruct2.Mode = GPIO_MODE_OUTPUT_PP; //普通推挽输出模式
GPIO_InitStruct2.Speed = GPIO_SPEED_FREQ_HIGH; //高速
GPIO_InitStruct2.Pull = GPIO_PULLUP; //上拉
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct2); //初始化GPIO
//DE 高发送 低接收
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_14, GPIO_PIN_SET);
//USART4 初始化设置
Uart4_Handle.Instance = UART4; //串口1
Uart4_Handle.Init.BaudRate = BPS; //波特率设置
Uart4_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart4_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart4_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart4_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart4_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart4_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart4_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart4_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart4_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(UART4_IRQn, 4, 4);
HAL_NVIC_EnableIRQ(UART4_IRQn);
}
void USART4_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart4_Handle, (uint8_t*)buff, Size);
}
void UART5_IRQHandler(void)
{
if(UART5_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U5RXOperation != NULL) Usart_ISR.U5RXOperation(RECV_BUF5);
}
HAL_UART_IRQHandler(&Uart5_Handle);
}
void USART5_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U5TXOver = Tx_Over; //发送完成回调
Usart_ISR.U5RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_UART5_CLK_ENABLE();
// __HAL_RCC_GPIOC_CLK_ENABLE();
// __HAL_RCC_GPIOD_CLK_ENABLE();
/**UART5 GPIO Configuration
PC12 ------> UART5_TX
PD2 ------> UART5_RX
*/
GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART5;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_2;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART5;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
//USART5 初始化设置
Uart5_Handle.Instance = UART5; //串口1
Uart5_Handle.Init.BaudRate = BPS; //波特率设置
Uart5_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart5_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart5_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart5_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart5_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart5_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart5_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart5_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart5_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(UART5_IRQn, 4, 5);
HAL_NVIC_EnableIRQ(UART5_IRQn);
}
void USART5_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart5_Handle, (uint8_t*)buff, Size);
}
void USART6_IRQHandler(void)
{
if(UART6_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U6RXOperation != NULL) Usart_ISR.U6RXOperation(RECV_BUF6);
}
HAL_UART_IRQHandler(&Uart6_Handle);
}
void USART6_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U6TXOver = Tx_Over; //发送完成回调
Usart_ISR.U6RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_USART6_CLK_ENABLE();
// __HAL_RCC_GPIOC_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_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_USART6;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
//USART6 初始化设置
Uart6_Handle.Instance = USART6; //串口1
Uart6_Handle.Init.BaudRate = BPS; //波特率设置
Uart6_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart6_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart6_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart6_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart6_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart6_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart6_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_SWAP_INIT;
Uart6_Handle.AdvancedInit.Swap = UART_ADVFEATURE_SWAP_ENABLE;
HAL_UART_Init(&Uart6_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart6_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(USART6_IRQn, 4, 6);
HAL_NVIC_EnableIRQ(USART6_IRQn);
}
void USART6_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart6_Handle, (uint8_t*)buff, Size);
}
void USART7_IRQHandler(void)
{
if(UART7_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U7RXOperation != NULL) Usart_ISR.U7RXOperation(RECV_BUF7);
}
HAL_UART_IRQHandler(&Uart7_Handle);
}
void USART7_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U7TXOver = Tx_Over; //发送完成回调
Usart_ISR.U7RXOperation = RxFunction; //接收数据函数
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct ;
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_UART7;
PeriphClkInitStruct.Usart234578ClockSelection = RCC_USART234578CLKSOURCE_D2PCLK1;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
{
// Error_Handler();
}
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
/**UART7 GPIO Configuration
PE7 ------> UART7_RX
PE8 ------> UART7_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF7_UART7;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
//USART7 初始化设置
Uart7_Handle.Instance = UART7; //串口1
Uart7_Handle.Init.BaudRate = BPS; //波特率设置
Uart7_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart7_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart7_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart7_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart7_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart7_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart7_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart7_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart7_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(UART7_IRQn, 0, 0);
//HAL_NVIC_EnableIRQ(UART7_IRQn);
}
void USART7_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart7_Handle, (uint8_t*)buff, Size);
}
void USART8_IRQHandler(void)
{
if(UART8_SR&UART_LSR_RDR) //接收到数据
{
if(Usart_ISR.U8RXOperation != NULL) Usart_ISR.U8RXOperation(RECV_BUF8);
}
HAL_UART_IRQHandler(&Uart8_Handle);
}
void USART8_Init(unsigned int BPS, void Tx_Over(void), void (*RxFunction)(unsigned char RX_Data))
{
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct ;
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_UART8;
PeriphClkInitStruct.Usart234578ClockSelection = RCC_USART234578CLKSOURCE_D2PCLK1;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
{
// Error_Handler();
}
__HAL_RCC_UART8_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStruct;
Usart_ISR.U8TXOver = Tx_Over; //发送完成回调
Usart_ISR.U8RXOperation = RxFunction; //接收数据函数
// __HAL_RCC_UART8_CLK_ENABLE();
// __HAL_RCC_GPIOE_CLK_ENABLE();
/**UART8 GPIO Configuration
PE0 ------> UART8_RX
PE1 ------> UART8_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF8_UART8;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
//USART8 初始化设置
Uart8_Handle.Instance = UART8; //串口1
Uart8_Handle.Init.BaudRate = BPS; //波特率设置
Uart8_Handle.Init.WordLength = UART_WORDLENGTH_8B; //8位
Uart8_Handle.Init.StopBits = UART_STOPBITS_1; //1个停止位
Uart8_Handle.Init.Parity = UART_PARITY_NONE; //无校验
Uart8_Handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流
Uart8_Handle.Init.Mode = UART_MODE_TX_RX; //串口发送,接收使能
Uart8_Handle.Init.OverSampling = UART_OVERSAMPLING_16; //16倍过采样
Uart8_Handle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
HAL_UART_Init(&Uart8_Handle); //初始化串口
__HAL_UART_ENABLE_IT(&Uart8_Handle, UART_IT_RXNE); //使能接收中断
HAL_NVIC_SetPriority(UART8_IRQn, 0,0);
HAL_NVIC_EnableIRQ(UART8_IRQn);
}
void USART8_Send(uint8_t *buff, uint16_t Size)
{
HAL_UART_Transmit_IT(&Uart8_Handle, (uint8_t*)buff, Size);
}
|
|
发表于 2024-8-11 14:57:30
发表于 2024-8-11 16:39:31
楼主
