695 lines
18 KiB
C
695 lines
18 KiB
C
#include "usart-board.h"
|
||
#include "usart.h"
|
||
#include <rtthread.h>
|
||
#if !defined(LOG_TAG)
|
||
#define LOG_TAG "uart"
|
||
#endif
|
||
#include <elog.h>
|
||
|
||
#define UART_LPUART1_BUFF_SIZE 256 // 4853
|
||
#define UART_LPUART2_BUFF_SIZE 2400 // gsm
|
||
#define UART_UART1_BUFF_SIZE 256 // 4852
|
||
#define UART_UART2_BUFF_SIZE 2048 // debbug
|
||
#define UART_UART3_BUFF_SIZE 256 // 4852
|
||
#define UART_UART4_BUFF_SIZE 2400 // eth1
|
||
#define UART_UART5_BUFF_SIZE 256 // 4851
|
||
#define UART_UART6_BUFF_SIZE 256 // view
|
||
|
||
|
||
|
||
static char s_lpuart1_buff[UART_LPUART1_BUFF_SIZE];
|
||
static char s_lpuart2_buff[UART_LPUART2_BUFF_SIZE];
|
||
static char s_uart1_buff[UART_UART1_BUFF_SIZE];
|
||
static char s_uart2_buff[UART_UART2_BUFF_SIZE];
|
||
static char s_uart3_buff[UART_UART3_BUFF_SIZE];
|
||
static char s_uart4_buff[UART_UART4_BUFF_SIZE];
|
||
static char s_uart5_buff[UART_UART5_BUFF_SIZE];
|
||
static char s_uart6_buff[UART_UART6_BUFF_SIZE];
|
||
|
||
|
||
#define RXBUFFERSIZE 2400
|
||
uint8_t aDmaLp2RxBuffer[RXBUFFERSIZE];
|
||
uint8_t aDmaU4RxBuffer [RXBUFFERSIZE];
|
||
|
||
|
||
extern UART_HandleTypeDef hlpuart1;
|
||
extern UART_HandleTypeDef hlpuart2;
|
||
extern UART_HandleTypeDef huart1;
|
||
extern UART_HandleTypeDef huart2;
|
||
extern UART_HandleTypeDef huart3;
|
||
extern UART_HandleTypeDef huart4;
|
||
extern UART_HandleTypeDef huart5;
|
||
extern UART_HandleTypeDef huart6;
|
||
|
||
UartDrv_t g_DebugDrv = { G0_UART2, 115200, PARITY_DATA_8N1, s_uart2_buff, 0, NULL, 0 }; // 调试串口驱动
|
||
UartDrv_t g_U4851Drv = { G0_UART5, 115200, PARITY_DATA_8N1, s_uart5_buff, 0, NULL, 0 }; // 4851 驱动
|
||
UartDrv_t g_U4852Drv = { G0_UART3, 115200, PARITY_DATA_8N1, s_uart3_buff, 0, NULL, 0 }; // 4852 驱动
|
||
UartDrv_t g_U4853Drv = { G0_UART1, 115200, PARITY_DATA_8N1, s_uart1_buff, 0, NULL, 0 }; // 4853 驱动
|
||
UartDrv_t g_ViewDrv = { G0_UART6, 115200, PARITY_DATA_8N1, s_uart6_buff, 0, NULL, 0 }; // view 驱动
|
||
UartDrv_t g_ETH1Drv = { G0_UART4, 115200, PARITY_DATA_8N1, s_uart4_buff, 0, NULL, 0 }; // 以太网通道1 驱动
|
||
UartDrv_t g_ETH2Drv = { G0_LPUART1, 115200, PARITY_DATA_8N1, s_lpuart1_buff, 0, NULL, 0 }; // 以太网通道2 驱动
|
||
UartDrv_t g_GSMDrv = { G0_LPUART2, 115200, PARITY_DATA_8N1, s_lpuart2_buff, 0, NULL, 0 }; // 4G模块 驱动
|
||
UartDrv_t g_LoRaDrv = { G0_UART3, 115200, PARITY_DATA_8N1, s_uart3_buff, 0, NULL, 0 }; // LoRa 模块驱动
|
||
|
||
|
||
void MX_UART_TickHandle (void)
|
||
{
|
||
// 调试串口
|
||
if (g_DebugDrv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_DebugDrv.rxdone != NULL)
|
||
{
|
||
g_DebugDrv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_DebugDrv.rx_timer > 1)
|
||
g_DebugDrv.rx_timer--;
|
||
|
||
// 4851
|
||
|
||
|
||
if (g_U4851Drv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_U4851Drv.rxdone != NULL)
|
||
{
|
||
g_U4851Drv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_U4851Drv.rx_timer > 1)
|
||
g_U4851Drv.rx_timer--;
|
||
// 4852
|
||
if (g_U4852Drv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_U4852Drv.rxdone != NULL)
|
||
{
|
||
g_U4852Drv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_U4852Drv.rx_timer > 1)
|
||
g_U4852Drv.rx_timer--;
|
||
|
||
// 4853
|
||
if (g_U4853Drv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_U4853Drv.rxdone != NULL)
|
||
{
|
||
g_U4853Drv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_U4853Drv.rx_timer > 1)
|
||
g_U4853Drv.rx_timer--;
|
||
// GSM
|
||
if (g_GSMDrv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_GSMDrv.rxdone != NULL)
|
||
{
|
||
g_GSMDrv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_GSMDrv.rx_timer > 1)
|
||
g_GSMDrv.rx_timer--;
|
||
// ETH1
|
||
if (g_ETH1Drv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_ETH1Drv.rxdone != NULL)
|
||
{
|
||
g_ETH1Drv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_ETH1Drv.rx_timer > 1)
|
||
g_ETH1Drv.rx_timer--;
|
||
// ETH2
|
||
if (g_ETH2Drv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_ETH2Drv.rxdone != NULL)
|
||
{
|
||
g_ETH2Drv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_ETH2Drv.rx_timer > 1)
|
||
g_ETH2Drv.rx_timer--;
|
||
//VIEW
|
||
if (g_ViewDrv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_ViewDrv.rxdone != NULL)
|
||
{
|
||
g_ViewDrv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_ViewDrv.rx_timer > 1)
|
||
g_ViewDrv.rx_timer--;
|
||
// LORA
|
||
if (g_LoRaDrv.rx_timer == 2) // 通过事件通知到业务app
|
||
{
|
||
if (g_LoRaDrv.rxdone != NULL)
|
||
{
|
||
g_LoRaDrv.rxdone();// 接受回调函数处理
|
||
}
|
||
}
|
||
if (g_LoRaDrv.rx_timer > 1)
|
||
g_LoRaDrv.rx_timer--;
|
||
|
||
}
|
||
|
||
|
||
/********************************************
|
||
函数名称：UartInfoInit
|
||
输入参数：串口句柄
|
||
输出参数：NULL
|
||
功能描述：初始化一个串口
|
||
********************************************/
|
||
|
||
|
||
void MX_UART_Init (UartDrv_t *drv)
|
||
{
|
||
uint32_t Parity = NULL, WordLength = NULL;
|
||
// 检验位
|
||
if (drv->DataParity && PARITY_EVEN_MASK != 0)
|
||
{
|
||
Parity = UART_PARITY_EVEN;
|
||
}
|
||
else if (drv->DataParity && PARITY_ODD_MASK != 0)
|
||
{
|
||
Parity = UART_PARITY_ODD;
|
||
}
|
||
else
|
||
{
|
||
Parity = UART_PARITY_NONE;
|
||
}
|
||
// 数据位
|
||
if (drv->DataParity && DATA8_MASK != 0)
|
||
{
|
||
WordLength = UART_WORDLENGTH_7B;
|
||
}
|
||
else
|
||
{
|
||
WordLength = UART_WORDLENGTH_8B;
|
||
}
|
||
switch (drv->Id)
|
||
{
|
||
case G0_LPUART1: // ETH2
|
||
{
|
||
hlpuart1.Instance = LPUART1;
|
||
hlpuart1.Init.BaudRate = drv->BaudRate;
|
||
hlpuart1.Init.WordLength = WordLength;
|
||
hlpuart1.Init.Parity = Parity;
|
||
hlpuart1.Init.StopBits = UART_STOPBITS_1;
|
||
hlpuart1.Init.Mode = UART_MODE_TX_RX;
|
||
hlpuart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
hlpuart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
hlpuart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
hlpuart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
hlpuart1.FifoMode = UART_FIFOMODE_DISABLE;
|
||
if (HAL_UART_Init (&hlpuart1) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_DisableFifoMode (&hlpuart1) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
__HAL_UART_ENABLE_IT (&hlpuart1, UART_IT_RXNE);
|
||
__HAL_UART_ENABLE_IT (&hlpuart1, UART_IT_ORE);
|
||
break;
|
||
}
|
||
case G0_LPUART2 : // GSM
|
||
hlpuart2.Instance = LPUART2;
|
||
hlpuart2.Init.BaudRate = drv->BaudRate;
|
||
hlpuart2.Init.WordLength = WordLength;
|
||
hlpuart2.Init.Parity = Parity;
|
||
hlpuart2.Init.StopBits = UART_STOPBITS_1;
|
||
hlpuart2.Init.Mode = UART_MODE_TX_RX;
|
||
hlpuart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
hlpuart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
hlpuart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
hlpuart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
hlpuart2.FifoMode = UART_FIFOMODE_DISABLE;
|
||
if (HAL_UART_Init (&hlpuart2) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetTxFifoThreshold (&hlpuart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetRxFifoThreshold (&hlpuart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_DisableFifoMode (&hlpuart2) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
//__HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_RXNE);
|
||
__HAL_UART_ENABLE_IT(&hlpuart2, UART_IT_IDLE);
|
||
__HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_ORE);
|
||
// __HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_NE);
|
||
// __HAL_UART_ENABLE_IT (&hlpuart2, UART_IT_FE);
|
||
if (HAL_UART_Receive_DMA (&hlpuart2, (uint8_t *) aDmaLp2RxBuffer, RXBUFFERSIZE) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
break;
|
||
case G0_UART1 : // 4853
|
||
huart1.Instance = USART1;
|
||
huart1.Init.BaudRate = drv->BaudRate;
|
||
huart1.Init.WordLength = WordLength;
|
||
huart1.Init.StopBits = UART_STOPBITS_1;
|
||
huart1.Init.Parity = Parity;
|
||
huart1.Init.Mode = UART_MODE_TX_RX;
|
||
huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart1.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
if (HAL_UART_Init (&huart1) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetTxFifoThreshold (&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetRxFifoThreshold (&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_DisableFifoMode (&huart1) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
break;
|
||
case G0_UART2: // debug
|
||
huart2.Instance = USART2;
|
||
huart2.Init.BaudRate = drv->BaudRate;
|
||
huart2.Init.WordLength = WordLength;
|
||
huart2.Init.StopBits = UART_STOPBITS_1;
|
||
huart2.Init.Parity = Parity;
|
||
huart2.Init.Mode = UART_MODE_TX_RX;
|
||
huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart2.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
// 初始化串口
|
||
if (HAL_UART_Init (&huart2) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetTxFifoThreshold (&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetRxFifoThreshold (&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_DisableFifoMode (&huart2) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
// 使能串口接受中断，用于接受数据
|
||
__HAL_UART_ENABLE_IT (&huart2, UART_IT_RXNE);
|
||
__HAL_UART_ENABLE_IT (&huart2, UART_IT_ORE);
|
||
break;
|
||
case G0_UART3: // 4852
|
||
huart3.Instance = USART3;
|
||
huart3.Init.BaudRate = drv->BaudRate;
|
||
huart3.Init.WordLength = WordLength;
|
||
huart3.Init.StopBits = UART_STOPBITS_1;
|
||
huart3.Init.Parity = Parity;
|
||
huart3.Init.Mode = UART_MODE_TX_RX;
|
||
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart3.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
if (HAL_UART_Init (&huart3) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetTxFifoThreshold (&huart3, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_SetRxFifoThreshold (&huart3, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UARTEx_DisableFifoMode (&huart3) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
__HAL_UART_ENABLE_IT (&huart3, UART_IT_ORE);
|
||
__HAL_UART_ENABLE_IT (&huart3, UART_IT_RXNE);
|
||
break;
|
||
case G0_UART4: // ETH1
|
||
huart4.Instance = USART4;
|
||
huart4.Init.BaudRate = drv->BaudRate;
|
||
huart4.Init.WordLength = WordLength;
|
||
huart4.Init.StopBits = UART_STOPBITS_1;
|
||
huart4.Init.Parity = Parity;
|
||
huart4.Init.Mode = UART_MODE_TX_RX;
|
||
huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart4.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
if (HAL_UART_Init (&huart4) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
/* USER CODE BEGIN USART4_Init 2 */
|
||
//__HAL_UART_ENABLE_IT (&huart4, UART_IT_RXNE);
|
||
__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
|
||
__HAL_UART_ENABLE_IT (&huart4, UART_IT_ORE);
|
||
if (HAL_UART_Receive_DMA (&huart4, (uint8_t *) aDmaU4RxBuffer, RXBUFFERSIZE) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
break;
|
||
case G0_UART5: // 4851
|
||
huart5.Instance = USART5;
|
||
huart5.Init.BaudRate = drv->BaudRate;
|
||
huart5.Init.WordLength = WordLength;
|
||
huart5.Init.StopBits = UART_STOPBITS_1;
|
||
huart5.Init.Parity = Parity;
|
||
huart5.Init.Mode = UART_MODE_TX_RX;
|
||
huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart5.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart5.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
if (HAL_UART_Init (&huart5) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
/* USER CODE BEGIN USART5_Init 2 */
|
||
__HAL_UART_ENABLE_IT (&huart5, UART_IT_ORE);
|
||
__HAL_UART_ENABLE_IT (&huart5, UART_IT_RXNE);
|
||
break;
|
||
case G0_UART6: // View
|
||
huart6.Instance = USART6;
|
||
huart6.Init.BaudRate = drv->BaudRate;
|
||
huart6.Init.WordLength = WordLength;
|
||
huart6.Init.StopBits = UART_STOPBITS_1;
|
||
huart6.Init.Parity = Parity;
|
||
huart6.Init.Mode = UART_MODE_TX_RX;
|
||
huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
huart6.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
huart6.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
|
||
huart6.Init.ClockPrescaler = UART_PRESCALER_DIV1;
|
||
huart6.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
|
||
if (HAL_UART_Init (&huart6) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
__HAL_UART_ENABLE_IT (&huart6, UART_IT_RXNE);
|
||
__HAL_UART_ENABLE_IT (&huart6, UART_IT_ORE);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
void MX_UART2_LPUART2_IRQHandle (void)
|
||
{
|
||
uint8_t ret;
|
||
// if (LPUART2->ISR & USART_ISR_RXNE_RXFNE)
|
||
// {
|
||
//
|
||
// ret = LPUART2->RDR;
|
||
// if (g_GSMDrv.rx_buffer != NULL)
|
||
// {
|
||
// g_GSMDrv.rx_buffer[g_GSMDrv.rx_size++] = ret;
|
||
// g_GSMDrv.rx_timer = 30; // 30ms
|
||
// if (g_GSMDrv.rx_size > UART_LPUART2_BUFF_SIZE)
|
||
// g_GSMDrv.rx_size = 0;
|
||
// }
|
||
// } debug
|
||
|
||
if (LPUART2->ISR & USART_ISR_ORE)
|
||
{
|
||
// rt_kprintf("ore:l2\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&hlpuart2, UART_CLEAR_OREF);
|
||
}
|
||
if (USART2->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:2\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&huart2, UART_CLEAR_OREF);
|
||
}
|
||
|
||
if (USART2->ISR & USART_ISR_RXNE_RXFNE) // 串口2
|
||
{
|
||
ret = USART2->RDR;
|
||
if (g_DebugDrv.rx_buffer != NULL)
|
||
{
|
||
g_DebugDrv.rx_buffer[g_DebugDrv.rx_size++] = ret;
|
||
g_DebugDrv.rx_timer = 30; // 30ms
|
||
if (g_DebugDrv.rx_size > UART_UART2_BUFF_SIZE)
|
||
g_DebugDrv.rx_size = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 串口空闲终端处理函数
|
||
void MX_UART2_LPUART2_IDLE_IRQHandle(void)
|
||
{
|
||
uint16_t ret;
|
||
|
||
if (LPUART2->ISR & USART_ISR_IDLE) // 串口空闲中断
|
||
{
|
||
ret = UART_LPUART2_BUFF_SIZE - __HAL_DMA_GET_COUNTER(hlpuart2.hdmarx); // 接收到数据的长度
|
||
if (ret > 0)
|
||
{
|
||
rt_memcpy(g_GSMDrv.rx_buffer,aDmaLp2RxBuffer,ret);
|
||
g_GSMDrv.rx_size = ret;
|
||
//g_GSMDrv.rxdone();
|
||
}
|
||
else
|
||
{
|
||
g_GSMDrv.rx_size = 0;
|
||
}
|
||
g_GSMDrv.rxdone();
|
||
__HAL_UART_CLEAR_FLAG(&hlpuart2, UART_CLEAR_IDLEF);
|
||
// 处理DMA 数据
|
||
}
|
||
// 处理DMA 数据
|
||
}
|
||
|
||
void MX_UART_IDLE_IRQHandle(void)
|
||
{
|
||
uint16_t ret;
|
||
|
||
if (USART4->ISR & USART_ISR_IDLE) // 串口空闲中断
|
||
{
|
||
|
||
ret = UART_UART4_BUFF_SIZE - __HAL_DMA_GET_COUNTER(huart4.hdmarx); // 接收到数据的长度
|
||
//log_i("MX_UART_IDLE_IRQHandle:%d",ret);
|
||
if (ret > 0)
|
||
{
|
||
rt_memcpy(g_ETH1Drv.rx_buffer,aDmaU4RxBuffer,ret);
|
||
g_ETH1Drv.rx_size = ret;
|
||
//g_ETH1Drv.rxdone();
|
||
}
|
||
else
|
||
{
|
||
g_ETH1Drv.rx_size = 0;
|
||
}
|
||
g_ETH1Drv.rxdone();
|
||
__HAL_UART_CLEAR_FLAG(&huart4, UART_CLEAR_IDLEF);
|
||
// 处理DMA 数据
|
||
}
|
||
// 处理DMA 数据
|
||
}
|
||
|
||
|
||
void MX_UART_IRQHandle (void)
|
||
{
|
||
uint8_t ret;
|
||
|
||
if (USART3->ISR & USART_ISR_RXNE_RXFNE) // 串口2
|
||
{
|
||
ret = USART3->RDR;
|
||
if (g_U4852Drv.rx_buffer != NULL)
|
||
{
|
||
g_U4852Drv.rx_buffer[g_U4852Drv.rx_size++] = ret;
|
||
g_U4852Drv.rx_timer = 30; // 30ms
|
||
if (g_U4852Drv.rx_size > UART_UART3_BUFF_SIZE)
|
||
g_U4852Drv.rx_size = 0;
|
||
}
|
||
}
|
||
// if (USART4->ISR & USART_ISR_RXNE_RXFNE)
|
||
// {
|
||
// ret = USART4->RDR;
|
||
// if (g_ETH1Drv.rx_buffer != NULL)
|
||
// {
|
||
// g_ETH1Drv.rx_buffer[g_ETH1Drv.rx_size++] = ret;
|
||
// g_ETH1Drv.rx_timer = 30; // 30ms
|
||
// if (g_ETH1Drv.rx_size > UART_UART4_BUFF_SIZE)
|
||
// g_ETH1Drv.rx_size = 0;
|
||
// }
|
||
// }
|
||
if (USART5->ISR & USART_ISR_RXNE_RXFNE)
|
||
{
|
||
ret = USART5->RDR;
|
||
if (g_U4851Drv.rx_buffer != NULL)
|
||
{
|
||
g_U4851Drv.rx_buffer[g_U4851Drv.rx_size++] = ret;
|
||
g_U4851Drv.rx_timer = 30; // 30ms
|
||
if (g_U4851Drv.rx_size > UART_UART5_BUFF_SIZE)
|
||
g_U4851Drv.rx_size = 0;
|
||
}
|
||
}
|
||
if (USART6->ISR & USART_ISR_RXNE_RXFNE)
|
||
{
|
||
ret = USART6->RDR;
|
||
|
||
if (g_ViewDrv.rx_buffer != NULL)
|
||
{
|
||
g_ViewDrv.rx_buffer[g_ViewDrv.rx_size++] = ret;
|
||
g_ViewDrv.rx_timer = 30; // 30ms
|
||
if (g_ViewDrv.rx_size > UART_UART6_BUFF_SIZE)
|
||
g_ViewDrv.rx_size = 0;
|
||
}
|
||
}
|
||
|
||
|
||
if (LPUART1->ISR & USART_ISR_RXNE_RXFNE)
|
||
{
|
||
ret = LPUART1->RDR;
|
||
if (g_ETH2Drv.rx_buffer != NULL)
|
||
{
|
||
g_ETH2Drv.rx_buffer[g_ETH2Drv.rx_size++] = ret;
|
||
g_ETH2Drv.rx_timer = 30; // 30ms
|
||
if (g_ETH2Drv.rx_size > UART_LPUART1_BUFF_SIZE)
|
||
g_ETH2Drv.rx_size = 0;
|
||
}
|
||
}
|
||
if (USART3->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:3\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&huart3, UART_CLEAR_OREF);
|
||
}
|
||
if (USART4->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:4\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&huart4, UART_CLEAR_OREF);
|
||
}
|
||
if (USART6->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:6\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&huart6, UART_CLEAR_OREF);
|
||
}
|
||
if (USART5->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:5\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&huart5, UART_CLEAR_OREF);
|
||
}
|
||
if (LPUART1->ISR & USART_ISR_ORE)
|
||
{
|
||
//rt_kprintf("ore:l1\r\n");
|
||
__HAL_UART_CLEAR_FLAG(&hlpuart1, UART_CLEAR_OREF);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void MX_UART_Clear (UartDrv_t * drv)
|
||
{
|
||
if (drv->Id == G0_LPUART2)
|
||
{
|
||
if (HAL_UART_AbortReceive(&hlpuart2) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UART_Receive_DMA (&hlpuart2, (uint8_t *) aDmaLp2RxBuffer, RXBUFFERSIZE) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
}
|
||
else if (drv->Id == G0_UART4)
|
||
{
|
||
if (HAL_UART_AbortReceive(&huart4) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
if (HAL_UART_Receive_DMA (&huart4, (uint8_t *) aDmaU4RxBuffer, RXBUFFERSIZE) != HAL_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
}
|
||
else {
|
||
drv->rx_size = 0;
|
||
drv->rx_timer = 0;
|
||
}
|
||
|
||
}
|
||
|
||
void MX_UART_PutChar (UartDrv_t * drv, char ch)
|
||
{
|
||
switch (drv->Id)
|
||
{
|
||
case G0_LPUART1:
|
||
HAL_UART_Transmit (&hlpuart1, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_LPUART2:
|
||
HAL_UART_Transmit (&hlpuart2, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART1:
|
||
HAL_UART_Transmit (&huart1, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART2:
|
||
HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART3:
|
||
HAL_UART_Transmit (&huart3, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART4:
|
||
HAL_UART_Transmit (&huart4, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART5:
|
||
HAL_UART_Transmit (&huart5, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
case G0_UART6:
|
||
HAL_UART_Transmit (&huart6, (uint8_t *) &ch, 1, 1000);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
void MX_UART_PutBuffer (UartDrv_t * drv, char *buff, int size)
|
||
{
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
MX_UART_PutChar (drv, buff[i]);
|
||
}
|
||
}
|
||
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
// 重定义fputc函数
|
||
int fputc (int ch, FILE *f)
|
||
{
|
||
HAL_UART_Transmit (&huart2, (uint8_t *) &ch, 1, 2000);
|
||
return ch;
|
||
}
|
||
|
||
|
||
|
||
|