524 lines
30 KiB
C
524 lines
30 KiB
C
#include "usart.h"
|
||
|
||
USART_ControlCB UART1_ControlCB; // 串口1控制结构体
|
||
uint8_t U1_TxBuff[U1_TXBUFF_SIZE]; // 定义一个数组缓冲区，串口1发送缓冲区
|
||
|
||
USART_ControlCB UART2_ControlCB; // 串口2控制结构体
|
||
uint8_t U2_TxBuff[U2_TXBUFF_SIZE]; // 定义一个数组缓冲区，串口2发送缓冲区
|
||
uint8_t U2_RxBuff[U2_RXBUFF_SIZE]; // 定义一个数组缓冲区，串口2发接收冲区
|
||
uint8_t U2_CopyBuff[U2_RXMAX_SIZE + 1]; //定义一个数组缓冲区，串口2拷贝接收数据
|
||
|
||
|
||
USART_ControlCB UART3_ControlCB; //串口3控制结构体
|
||
uint8_t U3_TxBuff[U3_TXBUFF_SIZE]; //定义一个数组缓冲区，串口3发送缓冲区
|
||
uint8_t U3_RxBuff[U3_RXBUFF_SIZE]; //定义一个数组缓冲区，串口3接收缓冲区
|
||
|
||
|
||
uint8_t TempBuff[512]; // 保存本次接收的，用于处理的数据
|
||
|
||
/**
|
||
* @brief USART1 Initialization Function
|
||
* @param None
|
||
* @retval None
|
||
*/
|
||
void usart1Init(uint32_t bound) {
|
||
UART1_ControlCB.USART_Handler.Instance = USART1;
|
||
UART1_ControlCB.USART_Handler.Init.BaudRate = bound;
|
||
UART1_ControlCB.USART_Handler.Init.WordLength = UART_WORDLENGTH_8B;
|
||
UART1_ControlCB.USART_Handler.Init.StopBits = UART_STOPBITS_1;
|
||
UART1_ControlCB.USART_Handler.Init.Parity = UART_PARITY_NONE;
|
||
UART1_ControlCB.USART_Handler.Init.Mode = UART_MODE_TX;
|
||
UART1_ControlCB.USART_Handler.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
UART1_ControlCB.USART_Handler.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
if (HAL_UART_Init(&UART1_ControlCB.USART_Handler) != HAL_OK)
|
||
Error_Handler();
|
||
}
|
||
|
||
/**
|
||
* @brief USART2 Initialization Function
|
||
* @param None
|
||
* @retval None
|
||
*/
|
||
void usart2Init(uint32_t bound) {
|
||
UART2_ControlCB.USART_Handler.Instance = USART2;
|
||
UART2_ControlCB.USART_Handler.Init.BaudRate = bound;
|
||
UART2_ControlCB.USART_Handler.Init.WordLength = UART_WORDLENGTH_8B;
|
||
UART2_ControlCB.USART_Handler.Init.StopBits = UART_STOPBITS_1;
|
||
UART2_ControlCB.USART_Handler.Init.Parity = UART_PARITY_NONE;
|
||
UART2_ControlCB.USART_Handler.Init.Mode = UART_MODE_TX_RX;
|
||
UART2_ControlCB.USART_Handler.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
UART2_ControlCB.USART_Handler.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
HAL_UART_Init(&UART2_ControlCB.USART_Handler);
|
||
if (HAL_UART_Init(&UART2_ControlCB.USART_Handler) != HAL_OK)
|
||
Error_Handler();
|
||
u2_BuffInit();
|
||
}
|
||
|
||
/*-------------------------------------------------*/
|
||
/*函数名：初始化串口3 */
|
||
/*参 数：bound：波特率 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void usart3Init(uint32_t bound) {
|
||
UART3_ControlCB.USART_Handler.Instance = USART3; // 指定使用第几个串口
|
||
UART3_ControlCB.USART_Handler.Init.BaudRate = bound; // 设置波特率
|
||
UART3_ControlCB.USART_Handler.Init.WordLength = UART_WORDLENGTH_8B; // 设置字长为8位数据格式
|
||
UART3_ControlCB.USART_Handler.Init.StopBits = UART_STOPBITS_1; // 设置一个停止位
|
||
UART3_ControlCB.USART_Handler.Init.Parity = UART_PARITY_NONE; // 设置无奇偶校验位
|
||
UART3_ControlCB.USART_Handler.Init.Mode = UART_MODE_TX_RX; // 设置收发模式
|
||
UART3_ControlCB.USART_Handler.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 设置无硬件流控
|
||
if (HAL_UART_Init(&UART3_ControlCB.USART_Handler) != HAL_OK) // 如果初始化失败
|
||
Error_Handler(); // 错误处理
|
||
u3_BuffInit(); // 初始化串口3收发缓冲区以及各个指针
|
||
}
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口1的底层初始化 */
|
||
/*参 数：huart：串口配置句柄 */
|
||
/*返回值：无 */
|
||
/*说 明：此函数会被HAL_UART_Init()回调调用 */
|
||
/*-------------------------------------------------*/
|
||
void HAL_UART_MspInit(UART_HandleTypeDef *huart) {
|
||
GPIO_InitTypeDef GPIO_InitStruct; // GPIO端口设置变量
|
||
|
||
if (huart->Instance == USART1) {
|
||
// 如果配置的是串口1，则进入改if分支，进行串口1的底层初始化
|
||
__HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA时钟
|
||
__HAL_RCC_USART1_CLK_ENABLE(); // 使能串口1时钟
|
||
|
||
/**USART1 GPIO Configuration
|
||
PA9 ------> USART1_TX
|
||
PA10 ------> USART1_RX
|
||
*/
|
||
GPIO_InitStruct.Pin = GPIO_PIN_9;
|
||
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_10;
|
||
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
|
||
GPIO_InitStruct.Pull = GPIO_NOPULL;
|
||
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
|
||
}
|
||
if (huart->Instance == USART3) {
|
||
__HAL_RCC_GPIOB_CLK_ENABLE(); // 使能GPIOB时钟
|
||
__HAL_RCC_USART3_CLK_ENABLE(); // 使能串口3时钟
|
||
__HAL_RCC_DMA1_CLK_ENABLE(); // 使能DMA1时钟
|
||
|
||
/**USART3 GPIO Configuration
|
||
PB10 ------> USART3_TX
|
||
PB11 ------> USART3_RX
|
||
*/
|
||
GPIO_InitStruct.Pin = GPIO_PIN_10;
|
||
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
|
||
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
|
||
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
|
||
|
||
GPIO_InitStruct.Pin = GPIO_PIN_11;
|
||
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
|
||
GPIO_InitStruct.Pull = GPIO_NOPULL;
|
||
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
|
||
|
||
/* USART3 interrupt Init */
|
||
HAL_NVIC_SetPriority(USART3_IRQn, 0, 2);
|
||
HAL_NVIC_EnableIRQ(USART3_IRQn);
|
||
|
||
/* USART3 DMA Init */
|
||
/* USART3_TX Init */
|
||
UART3_ControlCB.USART_TxDMA.Instance = DMA1_Channel2;
|
||
UART3_ControlCB.USART_TxDMA.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
|
||
UART3_ControlCB.USART_TxDMA.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
|
||
UART3_ControlCB.USART_TxDMA.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
|
||
UART3_ControlCB.USART_TxDMA.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //按字节存取
|
||
UART3_ControlCB.USART_TxDMA.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //按字节存取
|
||
UART3_ControlCB.USART_TxDMA.Init.Mode = DMA_NORMAL; //正常模式
|
||
UART3_ControlCB.USART_TxDMA.Init.Priority = DMA_PRIORITY_HIGH; //高优先级
|
||
if (HAL_DMA_Init(&UART3_ControlCB.USART_TxDMA) != HAL_OK)
|
||
Error_Handler();
|
||
|
||
__HAL_LINKDMA(huart, hdmatx, UART3_ControlCB.USART_TxDMA);
|
||
|
||
/* USART3_RX Init */
|
||
UART3_ControlCB.USART_RxDMA.Instance = DMA1_Channel3;
|
||
UART3_ControlCB.USART_RxDMA.Init.Direction = DMA_PERIPH_TO_MEMORY; //外设到存储区
|
||
UART3_ControlCB.USART_RxDMA.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
|
||
UART3_ControlCB.USART_RxDMA.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
|
||
UART3_ControlCB.USART_RxDMA.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //按字节存取
|
||
UART3_ControlCB.USART_RxDMA.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //按字节存取
|
||
UART3_ControlCB.USART_RxDMA.Init.Mode = DMA_NORMAL; //正常模式
|
||
UART3_ControlCB.USART_RxDMA.Init.Priority = DMA_PRIORITY_HIGH; //高优先级
|
||
if (HAL_DMA_Init(&UART3_ControlCB.USART_RxDMA) != HAL_OK)
|
||
Error_Handler();
|
||
|
||
__HAL_LINKDMA(huart, hdmarx, UART3_ControlCB.USART_RxDMA);
|
||
|
||
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);
|
||
}
|
||
if (huart->Instance == USART2) {
|
||
// 如果配置的是串口2，则进入改if分支，进行串口1的底层初始化
|
||
__HAL_RCC_GPIOA_CLK_ENABLE(); // 使能GPIOA时钟
|
||
__HAL_RCC_USART2_CLK_ENABLE(); // 使能串口2时钟
|
||
__HAL_RCC_DMA1_CLK_ENABLE(); // 使能DMA1时钟
|
||
|
||
/**USART2 GPIO Configuration
|
||
PA2 ------> USART2_TX
|
||
PA3 ------> USART2_RX
|
||
*/
|
||
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_InitStruct.Pull = GPIO_NOPULL;
|
||
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
|
||
|
||
HAL_NVIC_SetPriority(USART2_IRQn, 0, 2); // 设置串口2中断的抢占优先级为0，子优先级是2
|
||
HAL_NVIC_EnableIRQ(USART2_IRQn); // 使能串口2的中断
|
||
|
||
/* USART2 DMA Init */
|
||
/* USART2_TX Init */
|
||
UART2_ControlCB.USART_TxDMA.Instance = DMA1_Channel7; // DMA1通道7
|
||
UART2_ControlCB.USART_TxDMA.Init.Direction = DMA_MEMORY_TO_PERIPH; // 存储区到外设
|
||
UART2_ControlCB.USART_TxDMA.Init.PeriphInc = DMA_PINC_DISABLE; // 外设不递增
|
||
UART2_ControlCB.USART_TxDMA.Init.MemInc = DMA_MINC_ENABLE; // 存储区递增
|
||
UART2_ControlCB.USART_TxDMA.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; // 按字节存取
|
||
UART2_ControlCB.USART_TxDMA.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; // 按字节存取
|
||
UART2_ControlCB.USART_TxDMA.Init.Mode = DMA_NORMAL; // 正常模式
|
||
UART2_ControlCB.USART_TxDMA.Init.Priority = DMA_PRIORITY_HIGH; // 高优先级
|
||
if (HAL_DMA_Init(&UART2_ControlCB.USART_TxDMA) != HAL_OK)
|
||
Error_Handler();
|
||
|
||
__HAL_LINKDMA(huart, hdmatx, UART2_ControlCB.USART_TxDMA); // 和串口2 DMA发送连接
|
||
|
||
/* USART2_RX Init */
|
||
UART2_ControlCB.USART_RxDMA.Instance = DMA1_Channel6; // DMA1通道6
|
||
UART2_ControlCB.USART_RxDMA.Init.Direction = DMA_PERIPH_TO_MEMORY; // 外设到存储区
|
||
UART2_ControlCB.USART_RxDMA.Init.PeriphInc = DMA_PINC_DISABLE; // 外设不递增
|
||
UART2_ControlCB.USART_RxDMA.Init.MemInc = DMA_MINC_ENABLE; // 存储区递增
|
||
UART2_ControlCB.USART_RxDMA.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; // 按字节存取
|
||
UART2_ControlCB.USART_RxDMA.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; // 按字节存取
|
||
UART2_ControlCB.USART_RxDMA.Init.Mode = DMA_NORMAL; // 正常模式
|
||
UART2_ControlCB.USART_RxDMA.Init.Priority = DMA_PRIORITY_HIGH; // 高优先级
|
||
if (HAL_DMA_Init(&UART2_ControlCB.USART_RxDMA) != HAL_OK)
|
||
Error_Handler();
|
||
|
||
__HAL_LINKDMA(huart, hdmarx, UART2_ControlCB.USART_RxDMA); // 和串口2 DMA接收连接
|
||
|
||
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 0, 0); // 配置DMA1 通道1的中断，优先级
|
||
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn); // 使能DMA1 通道1的中断
|
||
|
||
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 0, 0); // 配置DMA1 通道6的中断，优先级
|
||
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn); // 使能DMA1 通道7的中断
|
||
}
|
||
|
||
}
|
||
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口1 printf函数 */
|
||
/*参 数：fmt,... 格式化输出字符串和参数 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void u1_printf(char *fmt, ...) {
|
||
uint16_t i;
|
||
va_list ap;
|
||
va_start(ap, fmt);
|
||
vsprintf((char *)U1_TxBuff, fmt, ap);
|
||
va_end(ap);
|
||
while (__HAL_UART_GET_FLAG(&UART1_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待串口1发送空闲，然后才能发送数据
|
||
for (i = 0; i < strlen((const char *)U1_TxBuff); i++) {
|
||
// 利用for循环，一个字节，一个字节的发送
|
||
UART1_ControlCB.USART_Handler.Instance->DR = U1_TxBuff[i]; // 把需要发送的字节，填充到串口1，启动发送
|
||
while (__HAL_UART_GET_FLAG(&UART1_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待本次字节发送结束，才可以发送下一个字节
|
||
}
|
||
}
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口2 printf函数 */
|
||
/*参 数：fmt,... 格式化输出字符串和参数 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void u2_printf(char* fmt,...) {
|
||
uint16_t i;
|
||
va_list ap;
|
||
va_start(ap,fmt);
|
||
vsprintf((char *)U2_TxBuff,fmt,ap);
|
||
va_end(ap);
|
||
|
||
while(__HAL_UART_GET_FLAG(&UART2_ControlCB.USART_Handler,UART_FLAG_TC)!=SET); //等待串口2发送空闲，然后才能发送数据
|
||
for(i = 0; i < strlen((const char*)U2_TxBuff); i ++) { //利用for循环，一个字节，一个字节的发送
|
||
UART2_ControlCB.USART_Handler.Instance->DR = U2_TxBuff[i]; //把需要发送的字节，填充到串口2，启动发送
|
||
while(__HAL_UART_GET_FLAG(&UART2_ControlCB.USART_Handler,UART_FLAG_TC)!=SET); //等待本次字节发送结束，才可以发送下一个字节
|
||
}
|
||
}
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口3 printf函数 */
|
||
/*参 数：fmt,... 格式化输出字符串和参数 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void u3_printf(char* fmt,...) {
|
||
uint16_t i;
|
||
va_list ap;
|
||
va_start(ap,fmt);
|
||
vsprintf((char *)U3_TxBuff,fmt,ap);
|
||
va_end(ap);
|
||
|
||
while(__HAL_UART_GET_FLAG(&UART3_ControlCB.USART_Handler,UART_FLAG_TC)!=SET); //等待串口3发送空闲，然后才能发送数据
|
||
for(i = 0; i < strlen((const char*)U3_TxBuff); i ++) { //利用for循环，一个字节，一个字节的发送
|
||
UART3_ControlCB.USART_Handler.Instance->DR = U3_TxBuff[i]; //把需要发送的字节，填充到串口3，启动发送
|
||
while(__HAL_UART_GET_FLAG(&UART3_ControlCB.USART_Handler,UART_FLAG_TC)!=SET); //等待本次字节发送结束，才可以发送下一个字节
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口2发送数据 */
|
||
/*参 数：data：数据 */
|
||
/*参 数：len：数据量 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void u2_TxData(uint8_t *data, uint16_t len) {
|
||
uint16_t i;
|
||
while (__HAL_UART_GET_FLAG(&UART2_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待串口1发送空闲，然后才能发送数据
|
||
for (i = 0; i < len; i++) {
|
||
// 循环一个一个字节的发送
|
||
UART2_ControlCB.USART_Handler.Instance->DR = data[i]; // 把需要发送的字节，填充到串口2，启动发送
|
||
while (__HAL_UART_GET_FLAG(&UART2_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待串口2发送空闲，然后才能发送数据
|
||
}
|
||
}
|
||
|
||
/*-------------------------------------------------*/
|
||
/*函数名：串口3发送数据 */
|
||
/*参 数：data：数据 */
|
||
/*参 数：len：数据量 */
|
||
/*返回值：无 */
|
||
/*-------------------------------------------------*/
|
||
void u3_TxData(uint8_t *data, uint16_t len) {
|
||
uint16_t i;
|
||
while (__HAL_UART_GET_FLAG(&UART3_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待串口3发送空闲，然后才能发送数据
|
||
for (i = 0; i < len; i++) {
|
||
// 循环一个一个字节的发送
|
||
UART3_ControlCB.USART_Handler.Instance->DR = data[i]; // 把需要发送的字节，填充到串口3，启动发送
|
||
while (__HAL_UART_GET_FLAG(&UART3_ControlCB.USART_Handler, UART_FLAG_TC) != SET); // 等待串口3发送空闲，然后才能发送数据
|
||
}
|
||
}
|
||
|
||
/*----------------------------------------------------------*/
|
||
/*函数名：初始化串口2收发缓冲区以及各个指针 */
|
||
/*参 数：无 */
|
||
/*返回值：无 */
|
||
/*----------------------------------------------------------*/
|
||
void u2_BuffInit(void) {
|
||
UART2_ControlCB.UsartTxDataInPtr = &UART2_ControlCB.Usart_TxLocation[0]; //发送缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
UART2_ControlCB.UsartTxDataOutPtr = UART2_ControlCB.UsartTxDataInPtr; //发送缓冲区 Out提取指针归位到 In插入指针位置
|
||
UART2_ControlCB.UsartTxDataEndPtr = &UART2_ControlCB.Usart_TxLocation[TX_NUM-1]; //发送缓冲区 End结尾标记指针归位到 位置结构体数组最后1个成员
|
||
UART2_ControlCB.UsartTxDataInPtr->StartPtr = U2_TxBuff; //In插入指向的数据成员 start指针指向发送缓冲区起始位置
|
||
UART2_ControlCB.Usart_TxCounter = 0; //累计发送缓冲区存放的数据量=0
|
||
UART2_ControlCB.Usart_TxCpltflag = 0; //发送空闲
|
||
UART2_ControlCB.Usart_TxTimer = HAL_GetTick(); //记录当前时间
|
||
|
||
UART2_ControlCB.UsartRxDataInPtr = &UART2_ControlCB.Usart_RxLocation[0]; //接收缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
UART2_ControlCB.UsartRxDataOutPtr = UART2_ControlCB.UsartRxDataInPtr; //接收缓冲区 Out提取指针归位到 In插入指针位置
|
||
UART2_ControlCB.UsartRxDataEndPtr = &UART2_ControlCB.Usart_RxLocation[RX_NUM-1]; //接收缓冲区 End结尾标记指针归位到 位置结构体数组最后1个成员
|
||
UART2_ControlCB.UsartRxDataInPtr->StartPtr = U2_RxBuff; //In插入指向的数据成员 start指针指向接收缓冲区起始位置
|
||
UART2_ControlCB.Usart_RxCounter = 0; //累计接收缓冲区存放的数据量=0
|
||
|
||
memset(U2_RxBuff,0,U2_RXBUFF_SIZE); //清空串口2 接收缓冲区
|
||
HAL_UART_Receive_DMA(&UART2_ControlCB.USART_Handler,UART2_ControlCB.UsartRxDataInPtr->StartPtr,U2_RXMAX_SIZE); //设置DMA接收 指定接收位置
|
||
__HAL_UART_CLEAR_IDLEFLAG(&UART2_ControlCB.USART_Handler); //清除空闲中断标志
|
||
__HAL_UART_ENABLE_IT(&UART2_ControlCB.USART_Handler, UART_IT_IDLE); //打开空闲中断
|
||
}
|
||
|
||
/*----------------------------------------------------------*/
|
||
/*函数名：初始化串口3收发缓冲区以及各个指针 */
|
||
/*参 数：无 */
|
||
/*返回值：无 */
|
||
/*----------------------------------------------------------*/
|
||
void u3_BuffInit(void) {
|
||
UART3_ControlCB.UsartTxDataInPtr = &UART3_ControlCB.Usart_TxLocation[0]; //发送缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
UART3_ControlCB.UsartTxDataOutPtr = UART3_ControlCB.UsartTxDataInPtr; //发送缓冲区 Out提取指针归位到 In插入指针位置
|
||
UART3_ControlCB.UsartTxDataEndPtr = &UART3_ControlCB.Usart_TxLocation[TX_NUM-1]; //发送缓冲区 End结尾标记指针归位到 位置结构体数组最后1个成员
|
||
UART3_ControlCB.UsartTxDataInPtr->StartPtr = U3_TxBuff; //In插入指向的数据成员 start指针指向发送缓冲区起始位置
|
||
UART3_ControlCB.Usart_TxCounter = 0; //累计发送缓冲区存放的数据量=0
|
||
UART3_ControlCB.Usart_TxCpltflag = 0; //发送空闲
|
||
UART3_ControlCB.Usart_TxTimer = HAL_GetTick(); //记录当前时间
|
||
|
||
UART3_ControlCB.UsartRxDataInPtr = &UART3_ControlCB.Usart_RxLocation[0]; //接收缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
UART3_ControlCB.UsartRxDataOutPtr = UART3_ControlCB.UsartRxDataInPtr; //接收缓冲区 Out提取指针归位到 In插入指针位置
|
||
UART3_ControlCB.UsartRxDataEndPtr = &UART3_ControlCB.Usart_RxLocation[RX_NUM-1]; //接收缓冲区 End结尾标记指针归位到 位置结构体数组最后1个成员
|
||
UART3_ControlCB.UsartRxDataInPtr->StartPtr = U3_RxBuff; //In插入指向的数据成员 start指针指向接收缓冲区起始位置
|
||
UART3_ControlCB.Usart_RxCounter = 0; //累计接收缓冲区存放的数据量=0
|
||
|
||
HAL_UART_Receive_DMA(&UART3_ControlCB.USART_Handler,UART3_ControlCB.UsartRxDataInPtr->StartPtr,U3_RXMAX_SIZE); //设置DMA接收 指定接收位置
|
||
__HAL_UART_CLEAR_IDLEFLAG(&UART3_ControlCB.USART_Handler); //清除空闲中断标志
|
||
__HAL_UART_ENABLE_IT(&UART3_ControlCB.USART_Handler, UART_IT_IDLE); //打开空闲中断
|
||
}
|
||
|
||
/*----------------------------------------------------------*/
|
||
/*函数名：向发送缓冲区添加数据 */
|
||
/*参 数：databuff：数据 */
|
||
/*参 数：datalen：数据长度 */
|
||
/*返回值：无 */
|
||
/*----------------------------------------------------------*/
|
||
void u2_TxDataBuf(uint8_t *databuff, uint32_t datalen) {
|
||
if (U2_TXBUFF_SIZE - UART2_ControlCB.Usart_TxCounter >= datalen) {
|
||
// 计算发送缓冲区内剩余的空间，还够不够存放本次的数据，够的话进入if
|
||
UART2_ControlCB.UsartTxDataInPtr->StartPtr = &U2_TxBuff[UART2_ControlCB.Usart_TxCounter]; // 标记本次存放数据的起始位置
|
||
} else {
|
||
// 反之，不够存放本次的数据，进入else
|
||
UART2_ControlCB.Usart_TxCounter = 0; // 累计发送缓冲区存放的数据量清零
|
||
UART2_ControlCB.UsartTxDataInPtr->StartPtr = U2_TxBuff; // 存放数据的起始位置重新设置到接收缓冲区的起始位置
|
||
}
|
||
memcpy(UART2_ControlCB.UsartTxDataInPtr->StartPtr, databuff, datalen); // 拷贝数据
|
||
UART2_ControlCB.Usart_TxCounter += datalen; // 计算累计发送缓冲区存放的数据量
|
||
UART2_ControlCB.UsartTxDataInPtr->EndPtr = &U2_TxBuff[UART2_ControlCB.Usart_TxCounter]; // 标记发送缓冲区本次存放的结束位置
|
||
|
||
UART2_ControlCB.UsartTxDataInPtr++; // 数据IN指针下移
|
||
if (UART2_ControlCB.UsartTxDataInPtr == UART2_ControlCB.UsartTxDataEndPtr) // 如果下移到End指针标记的结束位置，进入if
|
||
UART2_ControlCB.UsartTxDataInPtr = &UART2_ControlCB.Usart_TxLocation[0]; // 发送缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
}
|
||
|
||
/*----------------------------------------------------------*/
|
||
/*函数名：向发送缓冲区添加数据 */
|
||
/*参 数：databuff：数据 */
|
||
/*参 数：datalen：数据长度 */
|
||
/*返回值：无 */
|
||
/*----------------------------------------------------------*/
|
||
void u3_TxDataBuf(uint8_t *databuff, uint32_t datalen) {
|
||
if(U3_TXBUFF_SIZE - UART3_ControlCB.Usart_TxCounter >= datalen) { //计算发送缓冲区内剩余的空间，还够不够存放本次的数据，够的话进入if
|
||
UART3_ControlCB.UsartTxDataInPtr->StartPtr = &U3_TxBuff[UART3_ControlCB.Usart_TxCounter]; //标记本次存放数据的起始位置
|
||
} else { //反之，不够存放本次的数据，进入else
|
||
UART3_ControlCB.Usart_TxCounter = 0; //累计发送缓冲区存放的数据量清零
|
||
UART3_ControlCB.UsartTxDataInPtr->StartPtr = U3_TxBuff; //存放数据的起始位置重新设置到接收缓冲区的起始位置
|
||
}
|
||
memcpy(UART3_ControlCB.UsartTxDataInPtr->StartPtr,databuff,datalen); //拷贝数据
|
||
UART3_ControlCB.Usart_TxCounter += datalen; //计算累计发送缓冲区存放的数据量
|
||
UART3_ControlCB.UsartTxDataInPtr->EndPtr = &U3_TxBuff[UART3_ControlCB.Usart_TxCounter]; //标记发送缓冲区本次存放的结束位置
|
||
|
||
UART3_ControlCB.UsartTxDataInPtr++; //数据IN指针下移
|
||
if(UART3_ControlCB.UsartTxDataInPtr==UART3_ControlCB.UsartTxDataEndPtr) //如果下移到End指针标记的结束位置，进入if
|
||
UART3_ControlCB.UsartTxDataInPtr = &UART3_ControlCB.Usart_TxLocation[0]; //发送缓冲区 In插入指针归位到 位置结构体数组0号成员
|
||
}
|
||
|
||
|
||
|
||
|
||
/*-------------------------------------------------*/
|
||
/*函数名：卡模块发送指令 */
|
||
/*参 数：cmd：指令 */
|
||
/*参 数：ret：对比数据 */
|
||
/*参 数：timeout：超时时间（100ms的倍数） */
|
||
/*返回值：0：正确 其他：错误 */
|
||
/*-------------------------------------------------*/
|
||
char catSendCmd(char *cmd, char *ret, uint16_t timeout)
|
||
{
|
||
|
||
memset(U2_CopyBuff,0,U2_RXMAX_SIZE + 1); //清空串口接收缓冲区 //清空缓冲区
|
||
memcpy(U2_CopyBuff,UART2_ControlCB.UsartRxDataOutPtr->StartPtr,UART2_ControlCB.UsartRxDataOutPtr->EndPtr - UART2_ControlCB.UsartRxDataOutPtr->StartPtr);//拷贝数据
|
||
|
||
CAT1_printf("%s\r\n", cmd); //发送指令
|
||
while(timeout--)
|
||
{
|
||
HAL_Delay(100);
|
||
if (strstr((char *)U2_CopyBuff, ret)) //查找匹配字符串
|
||
break;
|
||
u1_printf("%d ", timeout); // 串口输出现在的超时时间
|
||
}
|
||
u1_printf("\r\n"); // 串口输出信息
|
||
if (timeout <= 0)
|
||
return 1; // 如果timeout<=0，说明超时时间到了，也没能收到OK，返回1
|
||
else
|
||
return 0; // 反之，表示正确，说明收到OK，通过break主动跳出while
|
||
}
|
||
|
||
|
||
|
||
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
/* 处 理 串 口 2 - 4 G 接 收 到 的 数 据 */
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
// 如果 UsartRxDataOutPtr指针 和 UsartRxDataInPtr指针不相等，则if成立，说明有数据接收到了
|
||
void usart2RxHandle(void) {
|
||
// uint16_t i = 0;
|
||
if(UART2_ControlCB.UsartRxDataOutPtr != UART2_ControlCB.UsartRxDataInPtr) {
|
||
u1_printf("串口2本次接收%d字节报文数据：\r\n",UART2_ControlCB.UsartRxDataOutPtr->EndPtr - UART2_ControlCB.UsartRxDataOutPtr->StartPtr); //串口输出数据
|
||
|
||
// for(i=0;i<UART2_ControlCB.UsartRxDataOutPtr->EndPtr - UART2_ControlCB.UsartRxDataOutPtr->StartPtr;i++)
|
||
// u1_printf("%02x ",UART2_ControlCB.UsartRxDataOutPtr->StartPtr[i]);
|
||
// u1_printf("\r\n\r\n");
|
||
|
||
memset(U2_CopyBuff,0,U2_RXMAX_SIZE + 1); //清空缓冲区
|
||
memcpy(U2_CopyBuff,UART2_ControlCB.UsartRxDataOutPtr->StartPtr,UART2_ControlCB.UsartRxDataOutPtr->EndPtr - UART2_ControlCB.UsartRxDataOutPtr->StartPtr);//拷贝数据
|
||
u2PassiveEvent(U2_CopyBuff,UART2_ControlCB.UsartRxDataOutPtr->EndPtr - UART2_ControlCB.UsartRxDataOutPtr->StartPtr); //处理串口2被动事件数据
|
||
UART2_ControlCB.UsartRxDataOutPtr ++; //Out指针下移
|
||
if(UART2_ControlCB.UsartRxDataOutPtr==UART2_ControlCB.UsartRxDataEndPtr) //如果下移到End指针标记的结尾位置
|
||
UART2_ControlCB.UsartRxDataOutPtr = &UART2_ControlCB.Usart_RxLocation[0]; //接收缓冲区Out插入指针归位到位置结构体数组0号成员
|
||
}
|
||
}
|
||
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
/* 处 理 串 口 2 - 4 G 模 块 发 送 的 数 据 */
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
// 如果 UsartTxDataOutPtr指针 和 UsartTxDataInPtr指针不相等 且 发送空闲 则if成立，说明有数据要发送
|
||
void usart2TxHandle(void) {
|
||
// uint16_t i = 0;
|
||
if((UART2_ControlCB.UsartTxDataOutPtr != UART2_ControlCB.UsartTxDataInPtr)&&(UART2_ControlCB.Usart_TxCpltflag == 0)) {
|
||
u1_printf("串口2本次发送%d字节数据\r\n",UART2_ControlCB.UsartTxDataOutPtr->EndPtr - UART2_ControlCB.UsartTxDataOutPtr->StartPtr);
|
||
|
||
// for(i=0;i<UART2_ControlCB.UsartTxDataOutPtr->EndPtr - UART2_ControlCB.UsartTxDataOutPtr->StartPtr;i++)
|
||
// u1_printf("%02x ",UART2_ControlCB.UsartTxDataOutPtr->StartPtr[i]);
|
||
// u1_printf("\r\n\r\n");
|
||
|
||
if(HAL_UART_Transmit_DMA(&UART2_ControlCB.USART_Handler,UART2_ControlCB.UsartTxDataOutPtr->StartPtr,UART2_ControlCB.UsartTxDataOutPtr->EndPtr - UART2_ControlCB.UsartTxDataOutPtr->StartPtr)== HAL_OK) {
|
||
UART2_ControlCB.Usart_TxCpltflag = 1; //发送中
|
||
UART2_ControlCB.UsartTxDataOutPtr ++; //Out指针下移
|
||
if(UART2_ControlCB.UsartTxDataOutPtr==UART2_ControlCB.UsartTxDataEndPtr) //如果下移到End指针标记的结尾位置
|
||
UART2_ControlCB.UsartTxDataOutPtr = &UART2_ControlCB.Usart_TxLocation[0]; //发送缓冲区Out插入指针归位到位置结构体数组0号成员
|
||
}
|
||
}
|
||
}
|
||
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
/* 处 理 串 口 3 - LoRA 接 收 到 的 数 据 */
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
// 如果 UsartRxDataOutPtr指针 和 UsartRxDataInPtr指针不相等，则if成立，说明有数据接收到了
|
||
void usart3RxHandle(void) {
|
||
// uint16_t i = 0;
|
||
if(UART3_ControlCB.UsartRxDataOutPtr != UART3_ControlCB.UsartRxDataInPtr) {
|
||
u1_printf("串口3本次接收%d字节报文数据：\r\n",UART3_ControlCB.UsartRxDataOutPtr->EndPtr - UART3_ControlCB.UsartRxDataOutPtr->StartPtr);
|
||
|
||
// for(i=0;i<UART3_ControlCB.UsartRxDataOutPtr->EndPtr - UART3_ControlCB.UsartRxDataOutPtr->StartPtr;i++)
|
||
// u1_printf("%02x ",UART3_ControlCB.UsartRxDataOutPtr->StartPtr[i]);
|
||
// u1_printf("\r\n\r\n");
|
||
|
||
u3PassiveEvent(UART3_ControlCB.UsartRxDataOutPtr->StartPtr,UART3_ControlCB.UsartRxDataOutPtr->EndPtr - UART3_ControlCB.UsartRxDataOutPtr->StartPtr); //处理串口4被动事件数据
|
||
UART3_ControlCB.UsartRxDataOutPtr ++; //Out指针下移
|
||
if(UART3_ControlCB.UsartRxDataOutPtr==UART3_ControlCB.UsartRxDataEndPtr) //如果下移到End指针标记的结尾位置
|
||
UART3_ControlCB.UsartRxDataOutPtr = &UART3_ControlCB.Usart_RxLocation[0]; //接收缓冲区Out插入指针归位到位置结构体数组0号成员
|
||
}
|
||
}
|
||
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
/* 处 理 串 口 3 - LoRA 模 块 发 送 的 数 据 */
|
||
/*-----------------------------------------------------------------------------------------*/
|
||
// 如果 UsartTxDataOutPtr指针 和 UsartTxDataInPtr指针不相等 且 发送空闲 且 距离上次发送间隔超过100ms 则if成立，说明有数据要发送
|
||
void usart3TxHandle(void) {
|
||
uint16_t i = 0;
|
||
if((UART3_ControlCB.UsartTxDataOutPtr != UART3_ControlCB.UsartTxDataInPtr)&&(UART3_ControlCB.Usart_TxCpltflag == 0)&&(HAL_GetTick() - UART3_ControlCB.Usart_TxTimer>100)) {
|
||
u1_printf("串口3本次发送%d字节数据\r\n",UART3_ControlCB.UsartTxDataOutPtr->EndPtr - UART3_ControlCB.UsartTxDataOutPtr->StartPtr);
|
||
|
||
// for(i=0;i<UART3_ControlCB.UsartTxDataOutPtr->EndPtr - UART3_ControlCB.UsartTxDataOutPtr->StartPtr;i++)
|
||
// u1_printf("%02x ",UART3_ControlCB.UsartTxDataOutPtr->StartPtr[i]);
|
||
// u1_printf("\r\n\r\n");
|
||
|
||
if(HAL_UART_Transmit_DMA(&UART3_ControlCB.USART_Handler,UART3_ControlCB.UsartTxDataOutPtr->StartPtr,UART3_ControlCB.UsartTxDataOutPtr->EndPtr - UART3_ControlCB.UsartTxDataOutPtr->StartPtr)== HAL_OK) {
|
||
UART3_ControlCB.Usart_TxCpltflag = 1; //发送中
|
||
UART3_ControlCB.UsartTxDataOutPtr ++; //Out指针下移
|
||
if(UART3_ControlCB.UsartTxDataOutPtr==UART3_ControlCB.UsartTxDataEndPtr) //如果下移到End指针标记的结尾位置
|
||
UART3_ControlCB.UsartTxDataOutPtr = &UART3_ControlCB.Usart_TxLocation[0]; //发送缓冲区Out插入指针归位到位置结构体数组0号成员
|
||
}
|
||
}
|
||
}
|