2017 lines
62 KiB
C
2017 lines
62 KiB
C
/*************************************
|
||
time:
|
||
auther:
|
||
change:
|
||
*************************************/
|
||
|
||
#include "usart.h"
|
||
#include "system.h"
|
||
|
||
struct tagUSARTDATA g_udUsart3Data; //串口2
|
||
|
||
typedef struct {
|
||
uint8_t buffer[UART_RX_BUFFER_SIZE];
|
||
volatile uint16_t head;
|
||
volatile uint16_t tail;
|
||
} RingBuffer;
|
||
|
||
static RingBuffer rx_buffer = {0};
|
||
static uint8_t tx_buffer[UART_TX_BUFFER_SIZE];
|
||
static volatile bool is_transmitting = false;
|
||
|
||
void UART_Init(uint32_t baudrate) {
|
||
|
||
Init_485EN();
|
||
// 时钟使能（与之前配置相同）
|
||
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
|
||
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
|
||
|
||
// GPIO配置（PB6/PB7复用功能）
|
||
GPIOB->MODER &= ~(GPIO_MODER_MODE6_0 | GPIO_MODER_MODE7_0);
|
||
GPIOB->MODER |= (GPIO_MODER_MODE6_1 | GPIO_MODER_MODE7_1);
|
||
GPIOB->AFR[0] |= (7 << GPIO_AFRL_AFSEL6_Pos) | (7 << GPIO_AFRL_AFSEL7_Pos);
|
||
|
||
// USART参数配置
|
||
USART1->BRR = SystemCoreClock / baudrate; // 简化计算，实际需要更精确的分频
|
||
//USART1->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
|
||
//USART1->CR1 |= USART_CR1_UE;
|
||
USART1->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE;
|
||
USART1->CR1 |= USART_CR1_RXNEIE; // 使能接收中断
|
||
// USART1->CR1 |= USART_CR1_RXNEIE; // 接收中断使能
|
||
USART1->CR3 |= USART_CR3_EIE; // 错误中断使能（包括ORE/FE/NE等）
|
||
|
||
// NVIC配置
|
||
NVIC_SetPriority(USART1_IRQn, 3);
|
||
NVIC_EnableIRQ(USART1_IRQn);
|
||
|
||
RS485_RX_EN;
|
||
|
||
}
|
||
//初始化485EN端口PB8为输出
|
||
void Init_485EN(void)
|
||
{
|
||
|
||
GPIO_InitTypeDef GPIO_InitStruct = {0};
|
||
__HAL_RCC_GPIOB_CLK_ENABLE();
|
||
GPIO_InitStruct.Pin = GPIO_PIN_8;
|
||
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
|
||
GPIO_InitStruct.Pull = GPIO_PULLUP; // 启用上拉
|
||
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; //高速模式
|
||
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
|
||
|
||
}
|
||
//初始化串口2
|
||
void USART3_Init(uint32_t baudrate)
|
||
{
|
||
InitUart3_485EN();
|
||
// 1. 使能时钟
|
||
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOCEN; // 使能GPIOC时钟
|
||
RCC->APB1ENR1 |= RCC_APB1ENR1_USART3EN; // 使能USART3时钟
|
||
|
||
// 2. 配置PC10(TX)和PC11(RX)为复用功能
|
||
GPIOC->MODER &= ~(GPIO_MODER_MODE10_Msk | GPIO_MODER_MODE11_Msk);
|
||
GPIOC->MODER |= (2 << GPIO_MODER_MODE10_Pos) | (2 << GPIO_MODER_MODE11_Pos); // PC10复用模式
|
||
// (2 << GPIO_MODER_MODE11_Pos); // PC11复用模式
|
||
|
||
// 3. 设置复用功能AF7（USART3）
|
||
// GPIOC->AFR[1] |= (7 << (4*(10-8))) | // PC10: AF7 (USART3_TX)
|
||
// (7 << (4*(11-8))); // PC11: AF7 (USART3_RX)
|
||
GPIOC->AFR[1] |= (7 << GPIO_AFRH_AFSEL10_Pos) | (7 << GPIO_AFRH_AFSEL11_Pos);
|
||
// 4. 配置GPIO参数
|
||
// GPIOC->OTYPER &= ~(GPIO_OTYPER_OT_10 | GPIO_OTYPER_OT_11); // 推挽输出
|
||
// GPIOC->OSPEEDR |= (3 << GPIO_OSPEEDR_OSPEED10_Pos) | // 高速模式
|
||
// (3 << GPIO_OSPEEDR_OSPEED11_Pos);
|
||
// GPIOC->PUPDR |= (1 << GPIO_PUPDR_PUPD11_Pos); // RX引脚上拉
|
||
|
||
// 5. 配置USART3参数
|
||
// USART3->BRR = (SystemCoreClock + baudrate/2) / baudrate; // 波特率计算
|
||
USART3->BRR = SystemCoreClock/4/baudrate; // 波特率计算
|
||
USART3->CR1 = USART_CR1_TE | USART_CR1_RE |USART_CR1_UE; // 发送使能
|
||
// USART_CR1_RE | // 接收使能
|
||
// USART_CR1_RXNEIE; // 接收中断使能
|
||
USART3->CR1 |= USART_CR1_RXNEIE; // 使能USART3
|
||
// 新增关键配置：使能错误中断检测
|
||
USART3->CR3 |= USART_CR3_EIE; // 使能错误中断
|
||
|
||
// 6. 配置NVIC中断
|
||
NVIC_SetPriority(USART3_IRQn, 2); // 中断优先级
|
||
NVIC_EnableIRQ(USART3_IRQn); // 使能中断
|
||
|
||
RS485_UART3RX_EN;
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
// RS485_UART2TX_EN;
|
||
// delay_ms(1);
|
||
// RS485_UART2RX_EN;
|
||
}
|
||
//初始化485EN端口PC12为输出
|
||
void InitUart3_485EN(void)
|
||
{
|
||
GPIO_InitTypeDef GPIO_InitStruct = {0};
|
||
__HAL_RCC_GPIOC_CLK_ENABLE();
|
||
GPIO_InitStruct.Pin = GPIO_PIN_12;
|
||
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 推挽输出
|
||
GPIO_InitStruct.Pull = GPIO_PULLUP; // 启用上拉
|
||
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; //高速模式
|
||
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
|
||
}
|
||
|
||
|
||
UART_Status UART_SendByte(uint8_t data) {
|
||
// if(is_transmitting) return UART_BUSY;
|
||
RS485_TX_EN;
|
||
delay_us(10);
|
||
// Delayus(200);
|
||
// USART1->TDR = data;
|
||
//// is_transmitting = true;
|
||
// USART1->CR1 |= USART_CR1_TCIE; // 使能传输完成中断
|
||
USART1->TDR = data;
|
||
// while(!(USART1->ISR & USART_ISR_TXE));
|
||
while(!(USART1->ISR & USART_ISR_TC)); // 等待传输完成
|
||
RS485_RX_EN;
|
||
// delay_us(100);
|
||
// RS485_RX_EN;
|
||
return UART_OK;
|
||
}
|
||
|
||
void UART_SendStr(uint8_t *PData,uint16_t Datalen)
|
||
{
|
||
RS485_TX_EN;
|
||
delay_us(10);
|
||
uint16_t i=0;
|
||
for(;i< Datalen;i++)
|
||
{
|
||
while(!(USART1->ISR & USART_ISR_TXE));
|
||
USART1->TDR = *(PData+i);
|
||
//USART_SendData(USARTx, *(PData+i));
|
||
//while (!USART_GetFlagStatus(USART1,USART_FLAG_TC));
|
||
}
|
||
while(!(USART1->ISR & USART_ISR_TC)); // 等待传输完成
|
||
RS485_RX_EN;
|
||
// while(*str) {
|
||
// while(!(USART1->ISR & USART_ISR_TXE));
|
||
// USART1->TDR = *str++;
|
||
// }
|
||
// return UART_OK;
|
||
// delay_us(100);
|
||
// RS485_RX_EN;
|
||
}
|
||
|
||
UART_Status UART_SendString(const char *str) {
|
||
|
||
RS485_TX_EN;
|
||
delay_us(10);
|
||
while(*str) {
|
||
while(!(USART1->ISR & USART_ISR_TXE));
|
||
USART1->TDR = *str++;
|
||
}
|
||
// delay_us(100);
|
||
// RS485_RX_EN;
|
||
while(!(USART1->ISR & USART_ISR_TC)); // 等待传输完成
|
||
RS485_RX_EN;
|
||
return UART_OK;
|
||
}
|
||
|
||
UART_Status UART3_SendByte(uint8_t data)
|
||
{
|
||
RS485_UART3TX_EN;
|
||
delay_us(10);
|
||
USART3->TDR = data;
|
||
while(!(USART3->ISR & USART_ISR_TC)); // 等待传输完成
|
||
RS485_UART3RX_EN;
|
||
return UART_OK;
|
||
}
|
||
|
||
void UART3_SendStr(uint8_t *PData,uint16_t Datalen)
|
||
{
|
||
RS485_UART3TX_EN;
|
||
delay_us(10);
|
||
uint16_t i=0;
|
||
for(;i< Datalen;i++)
|
||
{
|
||
while(!(USART3->ISR & USART_ISR_TXE));
|
||
USART3->TDR = *(PData+i);
|
||
}
|
||
while(!(USART3->ISR & USART_ISR_TC)); // 等待传输完成
|
||
RS485_UART3RX_EN;
|
||
}
|
||
//uint16_t UART_Available(void) {
|
||
// return (rx_buffer.head - rx_buffer.tail) % UART_RX_BUFFER_SIZE;
|
||
//}
|
||
|
||
//uint8_t UART_ReadByte(void) {
|
||
// if(rx_buffer.head == rx_buffer.tail) return 0;
|
||
//
|
||
// uint8_t data = rx_buffer.buffer[rx_buffer.tail];
|
||
// rx_buffer.tail = (rx_buffer.tail + 1) % UART_RX_BUFFER_SIZE;
|
||
// return data;
|
||
//}
|
||
|
||
//void UART_FlushRxBuffer(void) {
|
||
// rx_buffer.head = rx_buffer.tail = 0;
|
||
//}
|
||
|
||
// 中断服务函数
|
||
void USART1_IRQHandler(void) {
|
||
uint32_t isr = USART1->ISR;
|
||
|
||
/*---------- 处理接收数据中断 ----------*/
|
||
if (isr & USART_ISR_RXNE) { // 检查接收寄存器非空标志
|
||
// 读取接收数据寄存器（自动清除RXNE标志）
|
||
uint8_t data = USART1->RDR;
|
||
PushQueue(&RecQueue,data);
|
||
}
|
||
|
||
/*---------- 处理错误中断标志 ----------*/
|
||
// 错误处理（按严重性排序）
|
||
// uint32_t errors = 0;
|
||
// 溢出错误处理（重要：必须清除否则持续中断）
|
||
if (isr & USART_ISR_ORE) {
|
||
USART1->ICR |= USART_ICR_ORECF; // 写1清除溢出错误标志
|
||
// 可选：记录错误计数或处理策略
|
||
}
|
||
|
||
// 帧错误处理
|
||
if (isr & USART_ISR_FE) {
|
||
USART1->ICR |= USART_ICR_FECF; // 清除帧错误标志
|
||
}
|
||
|
||
// 噪声错误处理
|
||
if (isr & USART_ISR_NE) {
|
||
USART1->ICR |= USART_ICR_NCF; // 清除噪声错误标志
|
||
}
|
||
|
||
// 可选：其他错误检测（如校验错误）
|
||
// #ifdef USART_ISR_PE
|
||
// if (isr & USART_ISR_PE) {
|
||
// USART1->ICR |= USART_ICR_PECF; // 清除奇偶校验错误标志
|
||
// }
|
||
// #endif
|
||
// 接收中断处理
|
||
// if(USART1->ISR & USART_ISR_RXNE) {
|
||
// uint8_t data = USART1->RDR;
|
||
// PushQueue(&RecQueue,data);
|
||
//// uint16_t next_head = (rx_buffer.head + 1) % UART_RX_BUFFER_SIZE;
|
||
//
|
||
//// if(next_head != rx_buffer.tail) {
|
||
//// rx_buffer.buffer[rx_buffer.head] = data;
|
||
//// rx_buffer.head = next_head;
|
||
//// }
|
||
// }
|
||
|
||
// 传输完成中断处理
|
||
// if(USART1->ISR & USART_ISR_TC) {
|
||
// USART1->ICR |= USART_ICR_TCCF; // 清除传输完成标志
|
||
// USART1->CR1 &= ~USART_CR1_TCIE; // 禁用传输完成中断
|
||
//// is_transmitting = false;
|
||
// RS485_RX_EN;
|
||
// }
|
||
}
|
||
|
||
// 接收中断服务函数（增强版）
|
||
void USART3_IRQHandler(void)
|
||
{
|
||
uint32_t isr = USART3->ISR; // 读取中断状态寄存器
|
||
|
||
/*---------- 处理数据接收中断 ----------*/
|
||
if (isr & USART_ISR_RXNE) { // 接收寄存器非空
|
||
uint8_t data = USART3->RDR; // 读取数据（自动清除RXNE标志
|
||
Uart3Rcv(data);
|
||
// 存储到环形缓冲区
|
||
}
|
||
|
||
// 1. 溢出错误（Overrun Error）
|
||
if (isr & USART_ISR_ORE) {
|
||
// usart3_errors.overrun_errors++;
|
||
USART3->ICR |= USART_ICR_ORECF; // 清除溢出错误标志
|
||
}
|
||
|
||
// 2. 帧错误（Framing Error）
|
||
if (isr & USART_ISR_FE) {
|
||
// usart3_errors.framing_errors++;
|
||
USART3->ICR |= USART_ICR_FECF; // 清除帧错误标志
|
||
}
|
||
|
||
// 3. 噪声错误（Noise Error）
|
||
if (isr & USART_ISR_NE) {
|
||
// usart3_errors.noise_errors++;
|
||
USART3->ICR |= USART_ICR_NCF; // 清除噪声错误标志
|
||
}
|
||
|
||
// // 4. 奇偶校验错误（Parity Error）
|
||
// if (isr & USART_ISR_PE) {
|
||
// usart3_errors.parity_errors++;
|
||
// USART3->ICR |= USART_ICR_PECF; // 清除奇偶校验错误标志
|
||
// }
|
||
|
||
// /*---------------- 可选：接收超时处理 ----------------*/
|
||
// #ifdef USART_CR1_RTOIE
|
||
// if (isr & USART_ISR_RTOF) { // 接收超时标志
|
||
// USART3->ICR |= USART_ICR_RTOCF; // 清除超时标志
|
||
// // 此处可处理帧接收完成逻辑
|
||
// }
|
||
// #endif
|
||
|
||
}
|
||
|
||
|
||
//串口3数据接收 22.1.25
|
||
void Uart3Rcv(unsigned char ucReadData)
|
||
{
|
||
switch(g_udUsart3Data.usStatus)
|
||
{
|
||
case RcvSyn:
|
||
{
|
||
if( ucReadData == COMM_FRAME_HEAD)//判断起始位是否正确
|
||
{
|
||
g_udUsart3Data.usStatus = RcvtargetAddress;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
}
|
||
else
|
||
{
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
}
|
||
break;
|
||
}
|
||
case RcvtargetAddress://目的地址
|
||
{
|
||
g_udUsart3Data.ucRcvtargetAddress = ucReadData;
|
||
if(g_udUsart3Data.ucRcvtargetAddress == COMPARE55)
|
||
{
|
||
g_udUsart3Data.usStatus = RcvsourceAddress;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
}
|
||
else if(ucReadData == COMM_FRAME_HEAD)
|
||
{
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
g_udUsart3Data.usStatus = RcvtargetAddress;
|
||
}
|
||
else
|
||
{
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
}
|
||
break;
|
||
|
||
}
|
||
case RcvsourceAddress://接收源地址
|
||
{
|
||
g_udUsart3Data.ucRcvsourceAddress = ucReadData;
|
||
if(ucReadData == FREUENCYDATA) //接收双地址模块数据
|
||
{
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
}
|
||
else if((ucReadData == THORGHFARE0)||(ucReadData == THORGHFARE1))
|
||
{
|
||
g_udUsart3Data.usStatus = RcvaData;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
g_udUsart3Data.ucDataCount = 0;
|
||
}
|
||
else if(ucReadData == COMM_FRAME_HEAD)
|
||
{
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
g_udUsart3Data.usStatus = RcvtargetAddress;
|
||
}
|
||
else
|
||
{
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
}
|
||
break;
|
||
}
|
||
case RcvaData://接收数据
|
||
{
|
||
g_udUsart3Data.aData[g_udUsart3Data.ucDataCount] = ucReadData;
|
||
g_udUsart3Data.ucDataCount ++;
|
||
g_udUsart3Data.ucReceiveChkCrc += ucReadData;
|
||
|
||
if( g_udUsart3Data.ucDataCount >= DIELECTRICLEGTH)
|
||
{
|
||
g_udUsart3Data.usStatus = ChkSum;
|
||
}
|
||
break;
|
||
}
|
||
case ChkSum://CRC校验
|
||
{
|
||
if(ucReadData != g_udUsart3Data.ucReceiveChkCrc)
|
||
{
|
||
g_udUsart3Data.ucCommand = 0xFF;
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
}
|
||
else
|
||
{
|
||
g_udUsart3Data.usStatus = CmdOperate;
|
||
g_udUsart3Data.ucCommand = 0x00;
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
/****************************
|
||
//串口2接收处理函数 22.1.25
|
||
****************************/
|
||
void Uart3data_Processing(void)
|
||
{
|
||
unsigned int i;//,RX_SPEED,Setfdata=0;
|
||
//unsigned char chack_data_sum;
|
||
if(g_udUsart3Data.usStatus == CmdOperate)//如果有串口命令则处理
|
||
{
|
||
if( g_udUsart3Data.ucCommand == 0xFF )
|
||
{
|
||
g_udUsart3Data.ucCommand = 0x00;
|
||
}
|
||
else
|
||
{
|
||
switch(g_udUsart3Data.ucRcvsourceAddress)
|
||
{
|
||
case THORGHFARE0: //介电数据（内）
|
||
for(i=0;i<DIELECTRICLEGTH;i++)
|
||
{
|
||
MeasurementData_Farbit.ucDataValueBuf[i+75] = s_Data.ReceiveBuf[i];
|
||
}
|
||
break;
|
||
case THORGHFARE1: //介电数据（外）
|
||
for(i=0;i<DIELECTRICLEGTH;i++)
|
||
{
|
||
MeasurementData_Farbit.ucDataValueBuf[i+83] = s_Data.ReceiveBuf[i];
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
g_udUsart3Data.ucReceiveChkCrc = 0;
|
||
//ParallelUart_RevFlag = 0; //并口接收成功 2022.1.25
|
||
g_udUsart3Data.usStatus = RcvSyn;
|
||
g_Data.GetUart3OverFlag = 1;
|
||
}
|
||
}
|
||
//extern QueueHandle_t Uart_Queue_Handle;
|
||
//volatile uint8_t rx_len = 0; //接收一帧数据的长度
|
||
//volatile uint8_t recv_end_flag = 0; //一帧数据接收完成标志
|
||
//uint8_t rx_buffer[100]={0}; //接收数据缓存数组
|
||
|
||
////usart3 作为调试口，调用print 输出调测信息。
|
||
//#pragma import(__use_no_semihosting)
|
||
////标准库需要的支持函数
|
||
//struct __FILE
|
||
//{
|
||
// int handle;
|
||
//};
|
||
|
||
//FILE __stdout;
|
||
///**
|
||
// * @brief 定义_sys_exit()以避免使用半主机模式
|
||
// *
|
||
// * @param void
|
||
// *
|
||
// * @return void
|
||
// */
|
||
//void _sys_exit(int x)
|
||
//{
|
||
// x = x;
|
||
//}
|
||
///**
|
||
// * @brief 重定义fputc函数
|
||
// *
|
||
// * @param ch 输出字符量
|
||
// * @param f 文件指针
|
||
// *
|
||
// * @return void
|
||
// */
|
||
//int fputc(int ch, FILE *f)
|
||
//{
|
||
//#ifndef BNGF
|
||
// while((USART1->ISR & 0X40) == 0); //循环发送,直到发送完毕
|
||
//
|
||
// USART1->TDR = (u8) ch;
|
||
// return ch;
|
||
//#endif
|
||
//}
|
||
|
||
//void debug_printf(char *information,int len)
|
||
//{
|
||
// TX1_UART();TX1_UART();
|
||
// printf("\r\n");
|
||
// printf(information,len);
|
||
//}
|
||
|
||
////注意,读取USARTx->SR能避免莫名其妙的错误
|
||
//u8 USART_RX_BUF[USART3_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.
|
||
////接收状态
|
||
////bit15， 接收完成标志
|
||
////bit14， 接收到0x0d
|
||
////bit13~0， 接收到的有效字节数目
|
||
//u16 USART3_RX_STA = 0; //接收状态标记
|
||
///**
|
||
// * @brief 初始化串口3函数 作为调试输出口
|
||
// *
|
||
// * @param bound 串口波特率
|
||
// *
|
||
// * @return void
|
||
// */
|
||
////void uart3_init(u32 bound)
|
||
////{
|
||
//// //UART 初始化设置
|
||
//// huart3.Instance = USART3; //USART1
|
||
//// huart3.Init.BaudRate = bound; //波特率
|
||
//// huart3.Init.WordLength = UART_WORDLENGTH_8B; //字长为8位数据格式
|
||
//// huart3.Init.StopBits = UART_STOPBITS_1; //一个停止位
|
||
//// huart3.Init.Parity = UART_PARITY_NONE; //无奇偶校验位
|
||
//// huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; //无硬件流控
|
||
//// huart3.Init.Mode = UART_MODE_TX_RX; //收发模式
|
||
//// HAL_UART_Init(&huart3); //HAL_UART_Init()会使能UART1
|
||
|
||
//// __HAL_UART_CLEAR_IDLEFLAG(&huart3);//清除标志位
|
||
//// __HAL_UART_CLEAR_FLAG(&huart3,UART_IT_IDLE|UART_FLAG_NE|UART_FLAG_FE|UART_FLAG_TXE|UART_FLAG_TC);
|
||
////
|
||
//// HAL_NVIC_EnableIRQ(USART3_IRQn); //使能USART1中断通道
|
||
//// HAL_NVIC_SetPriority(USART3_IRQn, 3, 0); //抢占优先级3，子优先级3
|
||
//// HAL_UART_Receive_IT(&huart3, &usart1_buf.aRxBuff, 1);
|
||
//// __HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
|
||
//// __HAL_UART_CLEAR_IDLEFLAG(&huart3);//清除标志位
|
||
//// RX3_UART();
|
||
////}
|
||
|
||
|
||
|
||
///* USART1 init function */
|
||
|
||
//void MX_USART1_UART_Init(uint32_t bound)
|
||
//{
|
||
|
||
// huart1.Instance = USART1;
|
||
// huart1.Init.BaudRate = bound;
|
||
// huart1.Init.WordLength = UART_WORDLENGTH_8B;
|
||
// huart1.Init.StopBits = UART_STOPBITS_1;
|
||
// huart1.Init.Parity = UART_PARITY_NONE;
|
||
// huart1.Init.Mode = UART_MODE_TX_RX;
|
||
// huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
|
||
// //huart1.Init.OverSampling = UART_OVERSAMPLING_16;
|
||
// if (HAL_UART_Init(&huart1) != HAL_OK)
|
||
// {
|
||
// Error_Handler(1);
|
||
// }
|
||
// TX1_UART();
|
||
//// __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位
|
||
//// __HAL_UART_CLEAR_FLAG(&huart1,UART_IT_IDLE|UART_FLAG_NE|UART_FLAG_FE|UART_FLAG_TXE|UART_FLAG_TC);
|
||
////
|
||
//// HAL_NVIC_EnableIRQ(USART1_IRQn); //使能USART1中断通道
|
||
//// HAL_NVIC_SetPriority(USART1_IRQn, 3, 0); //抢占优先级3，子优先级3
|
||
//// HAL_UART_Receive_IT(&huart1, &usart1_buf.aRxBuff, 1);
|
||
//
|
||
////DMA接收函数，此句一定要加，不加接收不到第一次传进来的实数据，是空的，且此时接收到的数据长度为缓存器的数据长度
|
||
//// HAL_UART_Receive_DMA(&huart1,rx_buffer,USART_REC_LEN);
|
||
//}
|
||
|
||
//void MX_DMA_Init(void)
|
||
//{
|
||
//
|
||
// /* DMA controller clock enable */
|
||
// __HAL_RCC_DMA1_CLK_ENABLE();
|
||
|
||
// /* DMA1_Channel6_IRQn interrupt configuration */
|
||
// HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 1, 0);
|
||
// HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
|
||
// /* DMA2_Channel7_IRQn interrupt configuration */
|
||
//// HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 2, 0);
|
||
//// HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
|
||
//
|
||
|
||
//}
|
||
//void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
|
||
//{
|
||
// GPIO_InitTypeDef GPIO_InitStruct = {0};
|
||
// RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
|
||
// if(uartHandle->Instance==USART1)
|
||
// {
|
||
//// PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
|
||
//// PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
|
||
//// if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
|
||
//// {
|
||
//// Error_Handler(1);
|
||
//// printf("[%s] %d err\r\n",__func__,__LINE__);
|
||
//// }
|
||
// // USART1 clock enable 根据硬件打开对应时钟
|
||
// __HAL_RCC_USART1_CLK_ENABLE();
|
||
// __HAL_RCC_GPIOB_CLK_ENABLE();
|
||
|
||
// __HAL_RCC_GPIOD_CLK_ENABLE();
|
||
// #ifdef BAD_DEBUG
|
||
// __HAL_RCC_GPIOA_CLK_ENABLE();
|
||
// #endif
|
||
// #ifdef Board_VerE
|
||
// __HAL_RCC_GPIOA_CLK_ENABLE();
|
||
// #endif
|
||
// GPIO_InitStruct.Pin = UART_RD1_PIN ;
|
||
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
|
||
// GPIO_InitStruct.Pull = GPIO_NOPULL;//GPIO_PULLUP;
|
||
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
|
||
// HAL_GPIO_Init(UART_RD1_PORT, &GPIO_InitStruct);
|
||
//
|
||
//
|
||
// GPIO_InitStruct.Pin = UART1_RX_PIN|UART1_TX_PIN;
|
||
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
|
||
// GPIO_InitStruct.Pull = GPIO_NOPULL;//GPIO_PULLUP;//
|
||
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
|
||
// GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
|
||
// HAL_GPIO_Init(UART1_PORT, &GPIO_InitStruct);
|
||
// TX1_UART();
|
||
//
|
||
// // USART1 DMA Init
|
||
// // USART1_RX Init
|
||
// #ifndef debug_board
|
||
// /*
|
||
// hdma_usart1_rx.Instance = DMA1_Channel5;
|
||
// hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
|
||
// hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
|
||
// hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE;
|
||
// hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
|
||
// hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
|
||
// hdma_usart1_rx.Init.Mode = DMA_NORMAL;
|
||
// hdma_usart1_rx.Init.Priority = DMA_PRIORITY_HIGH;
|
||
// if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK)
|
||
// {
|
||
// Error_Handler(1);
|
||
// }
|
||
|
||
// __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx);
|
||
// */
|
||
///*
|
||
// // USART1_TX Init
|
||
// hdma_usart1_tx.Instance = DMA1_Channel4;
|
||
// hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
|
||
// hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
|
||
// hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
|
||
// hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
|
||
// hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
|
||
// hdma_usart1_tx.Init.Mode = DMA_NORMAL;
|
||
// hdma_usart1_tx.Init.Priority = DMA_PRIORITY_HIGH;
|
||
// if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)
|
||
// {
|
||
// Error_Handler(1);
|
||
// }
|
||
|
||
// __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx);
|
||
|
||
//*/
|
||
// #endif
|
||
//
|
||
// }
|
||
|
||
//// else if(uartHandle->Instance == USART3) //如果是串口1，进行串口1 MSP初始化
|
||
//// {
|
||
//// __HAL_RCC_GPIOA_CLK_ENABLE(); //使能GPIOA时钟
|
||
//// __HAL_RCC_GPIOC_CLK_ENABLE();
|
||
//// __HAL_RCC_USART3_CLK_ENABLE(); //使能USART3时钟
|
||
|
||
//// GPIO_InitStruct.Pin = UART3_RD_PIN ;
|
||
//// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
|
||
//// GPIO_InitStruct.Pull = GPIO_NOPULL;//GPIO_PULLUP;
|
||
//// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
|
||
//// HAL_GPIO_Init(UART3_RD_PORT, &GPIO_InitStruct);
|
||
////
|
||
//// GPIO_InitStruct.Pin = UART3_RX_PIN|UART3_TX_PIN;
|
||
//// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; //复用推挽输出
|
||
//// GPIO_InitStruct.Pull = GPIO_NOPULL;//GPIO_PULLUP; //上拉
|
||
//// GPIO_InitStruct.Speed = GPIO_SPEED_FAST; //高速
|
||
//// GPIO_InitStruct.Alternate = GPIO_AF7_USART3; //复用为USART2
|
||
//// HAL_GPIO_Init(UART3_PORT, &GPIO_InitStruct);
|
||
////
|
||
//// //HAL_NVIC_DisableIRQ(USART3_IRQn);
|
||
//// //TX3_UART();
|
||
//// }
|
||
|
||
//}
|
||
|
||
//void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
|
||
//{
|
||
|
||
//// if(uartHandle->Instance==USART1)
|
||
//// {
|
||
// // Peripheral clock disable
|
||
// __HAL_RCC_USART1_CLK_DISABLE();
|
||
// //PA9 ------> USART1_TX
|
||
// //PA10 ------> USART1_RX
|
||
// HAL_GPIO_DeInit(UART1_PORT, UART1_RX_PIN|UART1_RX_PIN);
|
||
// // USART1 DMA DeInit
|
||
// // HAL_DMA_DeInit(uartHandle->hdmarx);
|
||
// //HAL_DMA_DeInit(uartHandle->hdmatx);
|
||
|
||
// HAL_NVIC_DisableIRQ(USART1_IRQn);
|
||
|
||
//// }
|
||
//// else if(uartHandle->Instance==USART3)
|
||
//// {
|
||
//// // Peripheral clock disable
|
||
//// __HAL_RCC_USART3_CLK_DISABLE();
|
||
//// //PA9 ------> USART1_TX
|
||
//// //PA10 ------> USART1_RX
|
||
//// HAL_GPIO_DeInit(UART3_PORT, UART3_RX_PIN|UART3_RX_PIN);
|
||
|
||
//// HAL_NVIC_DisableIRQ(USART3_IRQn);
|
||
|
||
//// }
|
||
//}
|
||
|
||
|
||
//void HAL_UART_IDLECallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// //BaseType_t xHigherPriorityTaskWoken=1;
|
||
// u8 Res;
|
||
|
||
|
||
// if(huart->Instance == USART3)
|
||
// {
|
||
// Res = (uint8_t)(huart->Instance->RDR) ;
|
||
// usart1_buf.RxBuff[usart1_buf.RxSize++] = Res;
|
||
// if(usart1_buf.RxBuff[0]!=0xab)
|
||
// usart1_buf.RxSize=0;
|
||
// if(usart1_buf.RxSize>50)
|
||
// usart1_buf.RxSize=50;
|
||
// HAL_UART_Receive_IT(huart, &usart1_buf.aRxBuff, 1);
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET)
|
||
// {
|
||
// __HAL_UART_CLEAR_IDLEFLAG(huart);//清除标志位
|
||
//
|
||
// if(usart1_buf.RxBuff[0]==0Xab && usart1_buf.RxSize>4)
|
||
// {
|
||
// __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);//__HAL_UART_DISABLE_IT(&huart1, UART_IT_IDLE); //关闭idle中断
|
||
// //xQueueSendFromISR(Uart_Queue_Handle,usart1_buf.RxBuff ,&xHigherPriorityTaskWoken);//向队列中发送数据
|
||
// //portYIELD_FROM_ISR(xHigherPriorityTaskWoken);//必须有，否则不能切换任务
|
||
// }
|
||
// }
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_ORE) != RESET)
|
||
// {
|
||
// __HAL_UART_CLEAR_OREFLAG(huart);
|
||
// }
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_ORE) != RESET)
|
||
// {
|
||
//
|
||
// }
|
||
// }
|
||
|
||
//}
|
||
|
||
//void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// if(huart->Instance == USART3)
|
||
// {
|
||
// if(usart1_buf.Tx_end_flag == 0)
|
||
// {
|
||
// //debug_printf("\r\n\r\n发送完成，已发送字符个数为：%d\r\n",usart1_buf.TxSize);
|
||
// //usart1_buf.TxSize = 0;
|
||
// usart1_buf.Tx_end_flag = 1;
|
||
// //memset(usart1_buf.TxBuff,0,usart1_buf.TxSize);
|
||
// //RX3_UART();
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
////void USART3_IRQHandler(void)
|
||
////{
|
||
|
||
//// HAL_UART_IDLECallback(&huart3);
|
||
//// HAL_UART_IRQHandler(&huart3);
|
||
////// if(huart3.Instance != USART3)
|
||
////// {
|
||
////// uart3_init(57600);//MX_USART3_UART_Init(57600);
|
||
////// }
|
||
//// HAL_UART_ErrorCallback(&huart3);
|
||
////
|
||
////}
|
||
///**
|
||
// * @brief 串口3中断服务程序
|
||
// *
|
||
// * @remark 下面代码我们直接把中断控制逻辑写在中断服务函数内部
|
||
// * 说明：采用HAL库处理逻辑，效率不高。
|
||
// *
|
||
// * @param void
|
||
// *
|
||
// * @return void
|
||
// */
|
||
//void USART1_IRQHandler(void)
|
||
//{
|
||
//// u8 Res;
|
||
///*
|
||
// //HAL_UART_Receive(&huart3, &Res, 1, 1000);
|
||
// //HAL_UART_Receive_IT(&huart3, &usart1_buf.aRxBuff, 1);
|
||
// if((__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE) != RESET)) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
|
||
// {
|
||
// HAL_UART_Receive(&huart1, &Res, 1, 1000);
|
||
// HAL_UART_Receive_IT(&huart1, &usart1_buf.aRxBuff, 1);
|
||
// if((USART3_RX_STA & 0x8000) == 0) //接收未完成
|
||
// {
|
||
// if(USART3_RX_STA & 0x4000) //接收到了0x0d
|
||
// {
|
||
// if(Res != 0x0a)USART3_RX_STA = 0; //接收错误,重新开始
|
||
|
||
// else USART3_RX_STA |= 0x8000; //接收完成了
|
||
// }
|
||
// else //还没收到0X0D
|
||
// {
|
||
// if(Res == 0x0d)
|
||
// USART3_RX_STA |= 0x4000;
|
||
// else
|
||
// {
|
||
// USART_RX_BUF[USART3_RX_STA & 0X3FFF] = Res ;
|
||
// USART3_RX_STA++;
|
||
|
||
// if(USART3_RX_STA > (USART3_RX_LEN - 1))
|
||
// USART3_RX_STA = 0; //接收数据错误,重新开始接收
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// */
|
||
// HAL_UART_IRQHandler(&huart1);
|
||
//}
|
||
//void Error_Handler(uint8_t flag)
|
||
//{
|
||
// printf("error \r\n");
|
||
//}
|
||
//void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// if(HAL_UART_GetError(huart) & HAL_UART_ERROR_PE){ /*!< Parity error */
|
||
// //奇偶校验错误
|
||
// __HAL_UART_CLEAR_PEFLAG(huart);
|
||
// }else if(HAL_UART_GetError(huart) & HAL_UART_ERROR_NE){ /*!< Noise error */
|
||
// //噪声错误
|
||
// __HAL_UART_CLEAR_NEFLAG(huart);
|
||
// }else if(HAL_UART_GetError(huart) & HAL_UART_ERROR_FE){ /*!< Frame error */
|
||
// //帧格式错误
|
||
// __HAL_UART_CLEAR_FEFLAG(huart);
|
||
// }else if(HAL_UART_GetError(huart) & HAL_UART_ERROR_ORE){ /*!< Overrun error */
|
||
// //数据太多串口来不及接收错误
|
||
// __HAL_UART_CLEAR_OREFLAG(huart);
|
||
// }
|
||
// //当这个串口发生了错误，一定要在重新使能接收中断
|
||
// if(huart ->Instance == USART1){
|
||
// HAL_UART_Receive_IT(&huart1, &usart1_buf.aRxBuff, 1);
|
||
// }
|
||
//// if(huart ->Instance == USART3){
|
||
//// HAL_UART_Receive_IT(&huart3, &usart1_buf.aRxBuff, 1);
|
||
//// }
|
||
// //其他串口......
|
||
//}
|
||
|
||
////#include "./SYSTEM/sys/sys.h"
|
||
////#include "./SYSTEM/usart/usart.h"
|
||
|
||
//const char AT_STR[] = "AT"; // 0x4154
|
||
//const uint16_t CR_STR = 0x0A0D;//"\r\n"; 相反，高字节在前
|
||
|
||
//uint8_t Uart1_RX_Buffer[USART_MAX_LEN]; //设置接收缓存及发送缓存
|
||
//uint8_t Uart1_TX_Buffer[USART_MAX_LEN];
|
||
//UartBuff_TypeDef AtCmdUart;
|
||
//void BSP_AddBuff(UartBuff_TypeDef *hAtUart);
|
||
|
||
|
||
|
||
///* 如果使用os,则包括下面的头文件即可 */
|
||
//#if SYS_SUPPORT_OS
|
||
//#include "os.h" /* os 使用 */
|
||
//#endif
|
||
////UART_HandleTypeDef huart1;
|
||
///******************************************************************************************/
|
||
///* 加入以下代码, 支持printf函数, 而不需要选择use MicroLIB */
|
||
|
||
//#if 1
|
||
//#if (__ARMCC_VERSION >= 6010050) /* 使用AC6编译器时 */
|
||
//__asm(".global __use_no_semihosting\n\t"); /* 声明不使用半主机模式 */
|
||
//__asm(".global __ARM_use_no_argv \n\t"); /* AC6下需要声明main函数为无参数格式，否则部分例程可能出现半主机模式 */
|
||
|
||
//#else
|
||
///* 使用AC5编译器时, 要在这里定义__FILE 和 不使用半主机模式 */
|
||
//#pragma import(__use_no_semihosting)
|
||
|
||
//struct __FILE
|
||
//{
|
||
// int handle;
|
||
// /* Whatever you require here. If the only file you are using is */
|
||
// /* standard output using printf() for debugging, no file handling */
|
||
// /* is required. */
|
||
//};
|
||
|
||
//#endif
|
||
|
||
///* 不使用半主机模式，至少需要重定义_ttywrch\_sys_exit\_sys_command_string函数,以同时兼容AC6和AC5模式 */
|
||
//int _ttywrch(int ch)
|
||
//{
|
||
// ch = ch;
|
||
// return ch;
|
||
//}
|
||
|
||
///* 定义_sys_exit()以避免使用半主机模式 */
|
||
//void _sys_exit(int x)
|
||
//{
|
||
// x = x;
|
||
//}
|
||
|
||
//char *_sys_command_string(char *cmd, int len)
|
||
//{
|
||
// return NULL;
|
||
//}
|
||
|
||
///* FILE 在 stdio.h里面定义. */
|
||
//FILE __stdout;
|
||
|
||
///* 重定义fputc函数, printf函数最终会通过调用fputc输出字符串到串口 */
|
||
//int fputc(int ch, FILE *f)
|
||
//{
|
||
// while ((USART1->ISR & 0X40) == 0); /* 等待上一个字符发送完成 */
|
||
|
||
// USART1->TDR = (uint8_t)ch; /* 将要发送的字符 ch 写入到DR寄存器 */
|
||
// return ch;
|
||
//}
|
||
//#endif
|
||
/***********************************************END*******************************************/
|
||
|
||
//#if USART_EN_RX
|
||
// /* 如果使能了接收 */
|
||
|
||
///* 接收缓冲, 最大USART_REC_LEN个字节. */
|
||
//uint8_t g_usart_rx_buf[USART_REC_LEN];
|
||
|
||
///* 接收状态
|
||
// * bit15， 接收完成标志
|
||
// * bit14， 接收到0x0d
|
||
// * bit13~0， 接收到的有效字节数目
|
||
//*/
|
||
//uint16_t g_usart_rx_sta = 0;
|
||
|
||
//uint8_t g_rx_buffer[RXBUFFERSIZE]; /* HAL库使用的串口接收缓冲 */
|
||
|
||
//UART_HandleTypeDef g_uart1_handle; /* UART句柄 */
|
||
|
||
|
||
///**
|
||
// * @brief 串口X初始化函数
|
||
// * @param baudrate: 波特率, 根据自己需要设置波特率值
|
||
// * @note 注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
|
||
// * 这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
|
||
// * @retval 无
|
||
// */
|
||
//void usart_init(uint32_t baudrate)
|
||
//{
|
||
// g_uart1_handle.Instance = USART_UX; /* USART1 */
|
||
// g_uart1_handle.Init.BaudRate = baudrate; /* 波特率 */
|
||
// g_uart1_handle.Init.WordLength = UART_WORDLENGTH_8B; /* 字长为8位数据格式 */
|
||
// g_uart1_handle.Init.StopBits = UART_STOPBITS_1; /* 一个停止位 */
|
||
// g_uart1_handle.Init.Parity = UART_PARITY_NONE; /* 无奇偶校验位 */
|
||
// g_uart1_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE; /* 无硬件流控 */
|
||
// g_uart1_handle.Init.Mode = UART_MODE_TX_RX; /* 收发模式 */
|
||
// HAL_UART_Init(&g_uart1_handle); /* HAL_UART_Init()会使能UART1 */
|
||
//
|
||
// /* 该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量 */
|
||
// HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
|
||
//}
|
||
|
||
//void UartRD_Init(void)
|
||
//{
|
||
// /*
|
||
// RS485-EN PB8
|
||
// */
|
||
// GPIO_InitTypeDef GPIO_InitStruct;
|
||
|
||
// __HAL_RCC_GPIOB_CLK_ENABLE();
|
||
|
||
// GPIO_InitStruct.Pin = GPIO_PIN_8;
|
||
// GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
|
||
// GPIO_InitStruct.Pull = GPIO_PULLUP;
|
||
// GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
|
||
// HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
|
||
|
||
// HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
|
||
//}
|
||
|
||
|
||
///**
|
||
// * @brief UART底层初始化函数
|
||
// * @param huart: UART句柄类型指针
|
||
// * @note 此函数会被HAL_UART_Init()调用
|
||
// * 完成时钟使能，引脚配置，中断配置
|
||
// * @retval 无
|
||
// */
|
||
//void HAL_UART_MspInit(UART_HandleTypeDef *huart)
|
||
//{
|
||
// GPIO_InitTypeDef gpio_init_struct;
|
||
// if(huart->Instance == USART_UX) /* 如果是串口1，进行串口1 MSP初始化 */
|
||
// {
|
||
// USART_UX_CLK_ENABLE(); /* USART1 时钟使能 */
|
||
// USART_TX_GPIO_CLK_ENABLE(); /* 发送引脚时钟使能 */
|
||
// USART_RX_GPIO_CLK_ENABLE(); /* 接收引脚时钟使能 */
|
||
|
||
// gpio_init_struct.Pin = USART_TX_GPIO_PIN; /* TX引脚 */
|
||
// gpio_init_struct.Mode = GPIO_MODE_AF_PP; /* 复用推挽 */
|
||
// gpio_init_struct.Pull = GPIO_PULLUP; /* 上拉 */
|
||
// gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH; /* 高速 */
|
||
// gpio_init_struct.Alternate = USART_TX_GPIO_AF; /* 复用为USART1 */
|
||
// HAL_GPIO_Init(USART_TX_GPIO_PORT, &gpio_init_struct); /* 初始化发送引脚 */
|
||
|
||
// gpio_init_struct.Pin = USART_RX_GPIO_PIN; /* RX引脚 */
|
||
// gpio_init_struct.Alternate = USART_RX_GPIO_AF; /* 复用为USART1 */
|
||
// HAL_GPIO_Init(USART_RX_GPIO_PORT, &gpio_init_struct); /* 初始化接收引脚 */
|
||
|
||
//#if USART_EN_RX
|
||
// HAL_NVIC_EnableIRQ(USART_UX_IRQn); /* 使能USART1中断通道 */
|
||
// HAL_NVIC_SetPriority(USART_UX_IRQn, 3, 3); /* 抢占优先级3，子优先级3 */
|
||
//#endif
|
||
// }
|
||
//}
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_UART_RingBuff_Init;
|
||
////Brief: UART 打开中断，并设置UART 数据缓存
|
||
////=====================================================================//
|
||
//void BSP_UART_RingBuff_Init(UartBuff_TypeDef *hAtUart, UART_HandleTypeDef *huart,
|
||
// uint8_t* rxbuff, uint8_t* txbuff, uint16_t buffLen, uint8_t mode)
|
||
//{
|
||
|
||
// huart->pRxBuffPtr = rxbuff;
|
||
// huart->pTxBuffPtr = txbuff;
|
||
//
|
||
// huart->RxXferSize = 0;
|
||
// huart->TxXferSize = 0;
|
||
//
|
||
// huart->RxXferCount = 0;
|
||
// huart->TxXferCount = 0;
|
||
//
|
||
////#if defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
//// huart->State = HAL_UART_STATE_BUSY_RX;
|
||
////#elif defined (__STM32F1xx_HAL_H) || defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// huart->gState = HAL_UART_STATE_READY;
|
||
// huart->RxState = HAL_UART_STATE_BUSY_RX;
|
||
////#endif
|
||
//
|
||
// hAtUart->pUART = huart;
|
||
// hAtUart->mode = mode;
|
||
// hAtUart->CmdStatus = 0;
|
||
// hAtUart->BufferLen = buffLen;
|
||
//
|
||
// __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
|
||
// __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: bUART_IT_TxEnd;
|
||
////Brief: UART 中断处理调用函数
|
||
////=====================================================================//
|
||
//void bUART_IT_TxEnd(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// //UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
//}
|
||
|
||
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: bUART_IT_Rx;
|
||
////Brief: UART 中断处理调用函数
|
||
////=====================================================================//
|
||
//void bUART_IT_Rx(UartBuff_TypeDef *hAtUart, uint32_t errorflags)
|
||
//{
|
||
// UART_HandleTypeDef *huart =hAtUart->pUART;
|
||
//
|
||
////#if defined (__STM32F1xx_HAL_H) || defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
//// uint8_t data = (uint8_t)(hAtUart->pUART->Instance->DR);
|
||
////#elif defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32F3xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// uint8_t data = (uint8_t)(huart->Instance->RDR);
|
||
////#endif
|
||
//
|
||
// if(errorflags!=RESET)
|
||
// {
|
||
// // 错误数据不放入缓存
|
||
// return;
|
||
// }
|
||
//
|
||
// huart->pRxBuffPtr[huart->RxXferCount] = data;
|
||
//
|
||
// if(hAtUart->mode == UART_MODE_AT)
|
||
// {
|
||
// if((data == (uint8_t)AT_STR[0]) && (hAtUart->CmdStatus==0))//判断指令第一字节
|
||
// {
|
||
// hAtUart->CmdStatus = CMD_1ST;
|
||
// huart->pRxBuffPtr[0] = data;
|
||
// huart->RxXferSize=0;
|
||
// huart->RxXferCount=1;
|
||
// }
|
||
// else if( (data == (uint8_t)AT_STR[1]) && (huart->RxXferCount==1) &&
|
||
// (hAtUart->CmdStatus == CMD_1ST) ) //判断指令第二字节
|
||
// {
|
||
// hAtUart->CmdStatus = CMD_2ST;
|
||
// huart->RxXferCount++;
|
||
// }
|
||
// else if (hAtUart->CmdStatus == CMD_2ST)
|
||
// {
|
||
// huart->RxXferCount++;
|
||
// // 长度判断
|
||
// if (huart->RxXferCount>=hAtUart->BufferLen)
|
||
// {
|
||
// //超长
|
||
// hAtUart->CmdStatus=0;
|
||
// huart->RxXferCount=0;
|
||
// }else{
|
||
// // 回车判断
|
||
// if(data == 0x0A){
|
||
// if(huart->pRxBuffPtr[huart->RxXferCount - 2]==0x0D)
|
||
// {
|
||
// BSP_AddBuff(hAtUart);
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }else{
|
||
// }
|
||
// }else{ //____________ UART_MODE_DATA __________________________________//
|
||
// // 回车判断
|
||
// if(data == 0x0A)
|
||
// {
|
||
// if(huart->pRxBuffPtr[huart->RxXferCount - 1]==0x0D)
|
||
// {
|
||
// // 禁用idle中断避免重复进入
|
||
// __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);
|
||
// if (++huart->RxXferCount>=hAtUart->BufferLen) huart->RxXferCount=0;
|
||
// BSP_AddBuff(hAtUart);
|
||
// return;
|
||
// }
|
||
// }
|
||
//
|
||
// // 清IDLE标志
|
||
//#if defined (__STM32F1xx_HAL_H) || defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
// // 先读SR，再读DR ，清 IDLE | ORE | NE | FE | PE
|
||
//#elif defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// __HAL_UART_CLEAR_IT(huart, UART_CLEAR_IDLEF);
|
||
//#endif
|
||
// // 打开idle中断
|
||
// __HAL_UART_ENABLE_IT(huart, UART_IT_IDLE);
|
||
//
|
||
// if (++huart->RxXferCount>=hAtUart->BufferLen) huart->RxXferCount=0;
|
||
// }
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: bUART_IT_Idle;
|
||
////Brief: UART 中断处理调用函数
|
||
////=====================================================================//
|
||
//void bUART_IT_Idle(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// UART_HandleTypeDef *huart =hAtUart->pUART;
|
||
// __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);
|
||
//
|
||
// BSP_AddBuff(hAtUart);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_USART_IRQHandler;
|
||
////Brief: UART 中断处理调用函数
|
||
////=====================================================================//
|
||
//void bUART_IT_Tx(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// if (huart->TxXferCount != huart->TxXferSize ) // 未发送完成
|
||
// {
|
||
//#if defined (__STM32F1xx_HAL_H) || defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
// huart->Instance->DR = huart->pTxBuffPtr[huart->TxXferCount++];
|
||
//#elif defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// huart->Instance->TDR = huart->pTxBuffPtr[huart->TxXferCount++];
|
||
//#endif
|
||
// if (huart->TxXferCount >= hAtUart->BufferLen) huart->TxXferCount =0;
|
||
// }else{
|
||
// // 停止发送中断
|
||
// __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
|
||
//
|
||
//#if defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
// huart->State = HAL_UART_STATE_BUSY_RX;
|
||
//#elif defined (__STM32F1xx_HAL_H) || defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// huart->gState = HAL_UART_STATE_READY;
|
||
// huart->RxState = HAL_UART_STATE_BUSY_RX;
|
||
//#endif
|
||
//
|
||
// }
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_USART_IRQHandler;
|
||
////Brief: UART 中断处理调用函数
|
||
////=====================================================================//
|
||
//void BSP_USART_IRQHandler(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
//
|
||
////#if defined (__STM32F1xx_HAL_H) || defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
//// uint32_t isrflags= READ_REG(huart->Instance->SR);
|
||
////#elif defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) || defined (__STM32F3xx_HAL_H) || defined (__STM32L4xx_HAL_H)
|
||
// uint32_t isrflags= READ_REG(huart->Instance->ISR);
|
||
////#endif
|
||
// uint32_t cr1its = READ_REG(huart->Instance->CR1);
|
||
// uint32_t cr2its = READ_REG(huart->Instance->CR2);
|
||
// uint32_t cr3its = READ_REG(huart->Instance->CR3);
|
||
// uint32_t errorflags;
|
||
//
|
||
// errorflags = isrflags & 0x0000000F;
|
||
//
|
||
//#if defined (__STM32L4xx_HAL_H)
|
||
// // 清除 串口 Wakeup标志 2019-3-19
|
||
// if (((isrflags & USART_ISR_WUF) != RESET) && ((cr3its & USART_CR3_WUFIE) != RESET))
|
||
// {
|
||
// __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_WUF);
|
||
// }
|
||
//#endif
|
||
//
|
||
// if (errorflags != RESET)
|
||
// {//根据错误执行
|
||
// /*清除所有错误标志 */
|
||
//#if defined (__STM32F1xx_HAL_H) || defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
// // M3清错误标志，先读SR，再读DR ，清 IDLE | ORE | NE | FE | PE
|
||
// uint32_t tmp= READ_REG(huart->Instance->SR);
|
||
// tmp += READ_REG(huart->Instance->DR);
|
||
//#elif defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) //Cortex-M0
|
||
// __HAL_UART_CLEAR_IT(huart, 0x0000000F);
|
||
//#endif
|
||
// HAL_UART_ErrorCallback(huart);
|
||
|
||
//
|
||
// huart->ErrorCode |= HAL_UART_ERROR_PE;
|
||
// }
|
||
//
|
||
// //_______________________________________________________________________//
|
||
// //__ 接收中断 _________________________________________________________//
|
||
// if(((isrflags & UART_FLAG_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
|
||
// {
|
||
// bUART_IT_Rx(hAtUart,errorflags);
|
||
// return;
|
||
// }
|
||
//
|
||
// //_______________________________________________________________________//
|
||
// //__ 发送中断 _________________________________________________________//
|
||
// if(((isrflags & UART_FLAG_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
|
||
// {
|
||
// bUART_IT_Tx(hAtUart);
|
||
// }
|
||
//
|
||
// //_______________________________________________________________________//
|
||
// //__ 接收完成中断 ______________________________________________________//
|
||
// if(((isrflags & UART_FLAG_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
|
||
// {
|
||
// bUART_IT_TxEnd(hAtUart);
|
||
// return;
|
||
// }
|
||
//
|
||
//
|
||
// //_______________________________________________________________________//
|
||
// //__ 空闲中断 _________________________________________________________//
|
||
// if(((isrflags & UART_FLAG_IDLE) != RESET) && ((cr1its & USART_CR1_IDLEIE) != RESET))
|
||
// {
|
||
// bUART_IT_Idle(hAtUart);
|
||
// return;
|
||
// }
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_UART_Entel_Half;
|
||
////Brief: UART进入停机模式
|
||
////=====================================================================//
|
||
//void BSP_UART_Entel_Half(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// // GPIO_InitTypeDef GPIO_InitStruct;
|
||
// // 等待发送完成
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
//
|
||
// uint8_t timeout = 20; //等待200ms
|
||
// while (huart->TxXferCount != huart->TxXferSize ){
|
||
// if (--timeout==0){
|
||
// // 强行停止串口,避免死循环
|
||
// break;
|
||
// }
|
||
// HAL_Delay(10);
|
||
// }
|
||
//
|
||
// /* Peripheral interrupt Deinit*/
|
||
// HAL_NVIC_DisableIRQ(USART1_IRQn);
|
||
//
|
||
// /* Peripheral clock disable */
|
||
// __HAL_RCC_USART1_CLK_DISABLE();
|
||
// __HAL_UART_DISABLE(huart);
|
||
//
|
||
// // 如需要RX唤醒 使能 RX IO上升中断
|
||
// // GPIO_InitStruct.Pin = USART1_RX_Pin;
|
||
// // GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
|
||
// // GPIO_InitStruct.Pull = GPIO_PULLUP;
|
||
// // HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
|
||
// //
|
||
// // HAL_NVIC_SetPriority(EXTI15_10_IRQn, 2, 0);
|
||
// // HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
|
||
// // __HAL_GPIO_EXTI_CLEAR_IT(GPIO_InitStruct.Pin);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_UART_Exit_Half;
|
||
////Brief: UART换醒目后，进入正常工作状态
|
||
////=====================================================================//
|
||
//void BSP_UART_Exit_Half(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// // GPIO_InitTypeDef GPIO_InitStruct;
|
||
//
|
||
// huart->RxXferSize = 0;
|
||
// huart->TxXferSize = 0;
|
||
// huart->RxXferCount = 0;
|
||
// huart->TxXferCount = 0;
|
||
// hAtUart->CmdStatus = 0;
|
||
//
|
||
//
|
||
//#if defined (__STM32L1xx_HAL_H) // Cortex-M3
|
||
// huart->State = HAL_UART_STATE_BUSY_RX;
|
||
//#elif defined (__STM32F1xx_HAL_H) || defined (__STM32F0xx_HAL_H) || defined (__STM32L0xx_HAL_H) //Cortex-M0
|
||
// huart->gState = HAL_UART_STATE_READY;
|
||
// huart->RxState = HAL_UART_STATE_BUSY_RX;
|
||
//#endif
|
||
//
|
||
// // GPIO_InitStruct.Pin = USART1_RX_Pin;
|
||
// // GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
|
||
// // GPIO_InitStruct.Pull = GPIO_NOPULL;
|
||
// // HAL_GPIO_Init(USART1_RX_GPIO_Port, &GPIO_InitStruct);
|
||
// //MX_USART1_UART_Init(); //重新初始化
|
||
//
|
||
// __HAL_RCC_USART1_CLK_ENABLE();
|
||
// __HAL_UART_ENABLE(huart);
|
||
// HAL_NVIC_EnableIRQ(USART1_IRQn);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_AddBuff;
|
||
////Brief: 添加一条数据流到缓存里,等待处理
|
||
////=====================================================================//
|
||
//void BSP_AddBuff(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// StrBuff_TypeDef *combuff = &hAtUart->CmbBuff[hAtUart->HandlePtr];
|
||
// uint16_t size;
|
||
// uint16_t freelen;
|
||
// if(huart->RxXferCount > huart->RxXferSize )
|
||
// {
|
||
// size = huart->RxXferCount - huart->RxXferSize;
|
||
// memcpy(combuff->Buff, (huart->pRxBuffPtr + huart->RxXferSize), size);
|
||
//
|
||
// }else{ //跨越边界
|
||
// freelen = hAtUart->BufferLen - huart->RxXferSize;
|
||
// size = huart->RxXferCount + freelen;
|
||
//
|
||
// memcpy(combuff->Buff, (huart->pRxBuffPtr + huart->RxXferSize), freelen);
|
||
// memcpy((combuff->Buff + freelen), huart->pRxBuffPtr , huart->RxXferCount);
|
||
// }
|
||
//
|
||
// combuff->Len = size;
|
||
//
|
||
// if(++hAtUart->HandlePtr>=5) hAtUart->HandlePtr=0;
|
||
//
|
||
// //memset(huart->pRxBuffPtr,0,huart->RxXferCount);//填0
|
||
// huart->RxXferCount=0;
|
||
// huart->RxXferSize =0;
|
||
// hAtUart->CmdStatus =0;
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_SendChar;
|
||
////Brief: 发送一个字符，并打开串口中断
|
||
////=====================================================================//
|
||
//void BSP_SendChar(UartBuff_TypeDef *hAtUart, uint8_t ch)
|
||
//{
|
||
// //UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// UART_HandleTypeDef *huart = &g_uart1_handle;
|
||
// huart->pTxBuffPtr[huart->TxXferSize]=ch;
|
||
// if( ++(huart->TxXferSize) >= hAtUart->BufferLen ) huart->TxXferSize=0;
|
||
// __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_SendStr;
|
||
////Brief: 发送字符串，并打开串口中断
|
||
////=====================================================================//
|
||
//void BSP_SendStr(UartBuff_TypeDef *hAtUart, uint8_t *str,uint16_t len)
|
||
//{
|
||
// UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// uint16_t freelen = hAtUart->BufferLen - huart->TxXferSize;
|
||
// if (freelen >= len) // 有足够空余空间
|
||
// {
|
||
// memcpy( (huart->pTxBuffPtr+huart->TxXferSize), str, len);
|
||
// huart->TxXferSize += len;
|
||
// if( huart->TxXferSize >= hAtUart->BufferLen ) huart->TxXferSize -= hAtUart->BufferLen;
|
||
// }else{ // 跨越边界,先填充尾部，再填充头部
|
||
// memcpy( (huart->pTxBuffPtr+huart->TxXferSize), str, freelen);
|
||
// huart->TxXferSize = len-freelen;
|
||
// memcpy( huart->pTxBuffPtr, (str+freelen), huart->TxXferSize);
|
||
//
|
||
// }
|
||
// __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
|
||
//}
|
||
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_UART_Polling;
|
||
////Brief: 系统中周期查询数据流缓存
|
||
////=====================================================================//
|
||
//void BSP_UART_Polling(UartBuff_TypeDef *hAtUart)
|
||
//{
|
||
// //UART_HandleTypeDef *huart = hAtUart->pUART;
|
||
// StrBuff_TypeDef *combuff;
|
||
|
||
// while(hAtUart->HandlePtr != hAtUart->PresentPtr)
|
||
// {
|
||
// combuff = &hAtUart->CmbBuff[hAtUart->PresentPtr];
|
||
// // <* 处理串口的收据流，或解码AT指令 *>
|
||
// {
|
||
// BSP_UART_Callback(combuff->Buff,combuff->Len);
|
||
// }
|
||
// // <* END *>
|
||
// if(++hAtUart->PresentPtr>=5) hAtUart->PresentPtr=0;
|
||
// }
|
||
//
|
||
//}
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: BSP_UART_Callback;
|
||
////Brief: 处理字符串回调函数
|
||
////=====================================================================//
|
||
//__weak void BSP_UART_Callback(uint8_t *str,uint8_t len)
|
||
//{
|
||
// BSP_SendStr(&AtCmdUart,str,len);
|
||
//}
|
||
|
||
|
||
////=====================================================================//
|
||
////Description: ANO_F2I;
|
||
////Brief: 匿名 float to uint8_t
|
||
////=====================================================================//
|
||
//void ANO_F2I(uint8_t *pint8, float f,uint8_t *len)
|
||
//{
|
||
//#if (ANO_DEBUG==1)
|
||
// *pint8++ = BYTE3(f);
|
||
// *pint8++ = BYTE2(f);
|
||
// *pint8++ = BYTE1(f);
|
||
// *pint8 = BYTE0(f);
|
||
// *len +=4;
|
||
//#endif
|
||
//}
|
||
|
||
////=====================================================================//
|
||
////Description: ANO_F2I;
|
||
////Brief: 匿名产生校验字节
|
||
////=====================================================================//
|
||
//uint8_t ANO_sum(uint8_t *pint8, uint8_t len)
|
||
//{
|
||
//
|
||
// uint8_t sum=0;
|
||
// while(len-->0)
|
||
// sum += *pint8++;
|
||
// return sum;
|
||
//}
|
||
|
||
////=====================================================================//
|
||
////Description: ANO_F2I;
|
||
////Brief: 匿名 打印一组数据
|
||
////=====================================================================//
|
||
//void BSP_ANO( uint16_t x,uint16_t y,uint16_t z,uint16_t f,uint16_t p,uint16_t d)
|
||
//{
|
||
//#if (ANO_DEBUG==1)
|
||
// uint8_t ano[64]={0};
|
||
// uint8_t fun = 0xF1;
|
||
// uint8_t cnt=0;
|
||
//
|
||
// ano[cnt++]=0xAA;
|
||
// ano[cnt++]=0xAA;// 指令头
|
||
// ano[cnt++]=fun; // 功能/帧
|
||
// ano[cnt++]=0; // 长度
|
||
//
|
||
// ano[cnt++]= BYTE1(x);
|
||
// ano[cnt++]= BYTE0(x);
|
||
// ano[cnt++]= BYTE1(y);
|
||
// ano[cnt++]= BYTE0(y);
|
||
// ano[cnt++]= BYTE1(z);
|
||
// ano[cnt++]= BYTE0(z);
|
||
// ano[cnt++]= BYTE1(f);
|
||
// ano[cnt++]= BYTE0(f);
|
||
// ano[cnt++]= BYTE1(p);
|
||
// ano[cnt++]= BYTE0(p);
|
||
// ano[cnt++]= BYTE1(d);
|
||
// ano[cnt++]= BYTE0(d);
|
||
//// ANO_F2I( &ano[cnt],f,&cnt);
|
||
// ano[3]=cnt-4; // 长度
|
||
// ano[cnt]=ANO_sum(ano,cnt); //校验
|
||
// cnt++;
|
||
//
|
||
// BSP_SendStr(&AtCmdUart,ano,cnt);
|
||
//#endif
|
||
//}
|
||
|
||
|
||
//void HAL_UART_IDLECallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// BaseType_t xHigherPriorityTaskWoken=1;
|
||
// u8 Res;
|
||
|
||
|
||
// if(huart->Instance == USART3)
|
||
// {
|
||
// Res = (uint8_t)(huart->Instance->RDR) ;
|
||
// usart1_buf.RxBuff[usart1_buf.RxSize++] = Res;
|
||
// if(usart1_buf.RxBuff[0]!=0xab)
|
||
// usart1_buf.RxSize=0;
|
||
// if(usart1_buf.RxSize>50)
|
||
// usart1_buf.RxSize=50;
|
||
// HAL_UART_Receive_IT(huart, &usart1_buf.aRxBuff, 1);
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET)
|
||
// {
|
||
// __HAL_UART_CLEAR_IDLEFLAG(huart);//清除标志位
|
||
//
|
||
// if(usart1_buf.RxBuff[0]==0Xab && usart1_buf.RxSize>4)
|
||
// {
|
||
// __HAL_UART_DISABLE_IT(huart, UART_IT_IDLE);//__HAL_UART_DISABLE_IT(&huart1, UART_IT_IDLE); //关闭idle中断
|
||
// xQueueSendFromISR(Uart_Queue_Handle,usart1_buf.RxBuff ,&xHigherPriorityTaskWoken);//向队列中发送数据
|
||
// //portYIELD_FROM_ISR(xHigherPriorityTaskWoken);//必须有，否则不能切换任务
|
||
// }
|
||
// }
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_ORE) != RESET)
|
||
// {
|
||
// __HAL_UART_CLEAR_OREFLAG(huart);
|
||
// }
|
||
// if(__HAL_UART_GET_FLAG(huart,UART_FLAG_ORE) != RESET)
|
||
// {
|
||
//
|
||
// }
|
||
//
|
||
// }
|
||
|
||
//}
|
||
|
||
//void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// if(huart->Instance == USART3)
|
||
// {
|
||
// if(usart1_buf.Tx_end_flag == 0)
|
||
// {
|
||
// //debug_printf("\r\n\r\n发送完成，已发送字符个数为：%d\r\n",usart1_buf.TxSize);
|
||
// //usart1_buf.TxSize = 0;
|
||
// usart1_buf.Tx_end_flag = 1;
|
||
// //memset(usart1_buf.TxBuff,0,usart1_buf.TxSize);
|
||
// RX3_UART();
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
///**
|
||
// * @brief Rx传输回调函数
|
||
// * @param huart: UART句柄类型指针
|
||
// * @retval 无
|
||
// */
|
||
//void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
|
||
//{
|
||
// if(huart->Instance == USART_UX) /* 如果是串口1 */
|
||
// {
|
||
// if((g_usart_rx_sta & 0x8000) == 0) /* 接收未完成 */
|
||
// {
|
||
// if(g_usart_rx_sta & 0x4000) /* 接收到了0x0d */
|
||
// {
|
||
// if(g_rx_buffer[0] != 0x0a)
|
||
// {
|
||
// g_usart_rx_sta = 0; /* 接收错误,重新开始 */
|
||
// }
|
||
// else
|
||
// {
|
||
// g_usart_rx_sta |= 0x8000; /* 接收完成了 */
|
||
// }
|
||
// }
|
||
// else /* 还没收到0X0D */
|
||
// {
|
||
// if(g_rx_buffer[0] == 0x0d)
|
||
// {
|
||
// g_usart_rx_sta |= 0x4000;
|
||
// }
|
||
// else
|
||
// {
|
||
// g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0] ;
|
||
// g_usart_rx_sta++;
|
||
// if(g_usart_rx_sta > (USART_REC_LEN - 1))
|
||
// {
|
||
// g_usart_rx_sta = 0; /* 接收数据错误,重新开始接收 */
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// HAL_UART_Receive_IT(&g_uart1_handle, (uint8_t *)g_rx_buffer, RXBUFFERSIZE);
|
||
// }
|
||
//}
|
||
|
||
///**
|
||
// * @brief 串口1中断服务函数
|
||
// * @param 无
|
||
// * @retval 无
|
||
// */
|
||
//void USART_UX_IRQHandler(void)
|
||
//{
|
||
//#if SYS_SUPPORT_OS /* 使用OS */
|
||
// OSIntEnter();
|
||
//#endif
|
||
|
||
// HAL_UART_IRQHandler(&g_uart1_handle); /* 调用HAL库中断处理公用函数 */
|
||
|
||
//#if SYS_SUPPORT_OS /* 使用OS */
|
||
// OSIntExit();
|
||
//#endif
|
||
//}
|
||
|
||
//#endif
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//unsigned char Test_Data_Flag = 0;
|
||
|
||
//#if 1
|
||
////重定向c库函数printf到USART1
|
||
//int fputc(int ch, FILE *f)
|
||
//{
|
||
///* 发送一个字节数据到USART1 */
|
||
// USART_SendData(USART1, (uint8_t) ch);
|
||
|
||
// /* 等待发送完毕 */
|
||
// while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
|
||
// return (ch);
|
||
//}
|
||
//#endif
|
||
////串口1配置 2022.2.5
|
||
////修改串口为PB6 PB7 2022.2.5
|
||
//void USART1_Config(u32 bound)
|
||
//{
|
||
// USART_InitTypeDef USART_InitStructure;
|
||
// GPIO_InitTypeDef GPIO_InitStructure;
|
||
// NVIC_InitTypeDef NVIC_InitStruct;
|
||
//
|
||
// RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
|
||
// RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
|
||
//
|
||
// GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_6 | GPIO_Pin_7); //USART1对应的TX，RX,引脚 PB6 PB7
|
||
// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //复用模式
|
||
// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
// GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
|
||
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
|
||
// GPIO_Init(GPIOB, &GPIO_InitStructure);
|
||
//
|
||
// GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_8); //485使能 PB8
|
||
// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
|
||
// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
// GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
|
||
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
|
||
// GPIO_Init(GPIOB, &GPIO_InitStructure);
|
||
//
|
||
// //配置复用功能
|
||
// GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_7);
|
||
// GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_7);
|
||
//
|
||
// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
|
||
// NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
|
||
// NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
|
||
// NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
|
||
// NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
|
||
// NVIC_Init(&NVIC_InitStruct);
|
||
//
|
||
// //USART_InitStructure.USART_BaudRate = 115200;
|
||
// USART_InitStructure.USART_BaudRate = bound;
|
||
// USART_InitStructure.USART_WordLength = USART_WordLength_8b;
|
||
// USART_InitStructure.USART_StopBits = USART_StopBits_1;
|
||
// USART_InitStructure.USART_Parity = USART_Parity_No;
|
||
// USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
|
||
// USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
|
||
//
|
||
// USART_DeInit(USART1);
|
||
// USART_Init(USART1, &USART_InitStructure);
|
||
// USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);//使能中断
|
||
// USART_ClearFlag(USART1,USART_FLAG_TC);
|
||
// USART_Cmd(USART1, ENABLE);
|
||
//
|
||
// RS485_RX_EN;
|
||
//}
|
||
|
||
//void USART_SendStr(USART_TypeDef* USARTx, uint8_t *PData,uint16_t Datalen)
|
||
//{
|
||
// RS485_TX_EN;
|
||
// Delayus(200);
|
||
// u16 i=0;
|
||
// for(;i< Datalen;i++)
|
||
// {
|
||
// USART_SendData(USARTx, *(PData+i));
|
||
// while (!USART_GetFlagStatus(USART1,USART_FLAG_TC));
|
||
// }
|
||
// RS485_RX_EN;
|
||
//
|
||
//}
|
||
|
||
//void USART_SentByte(USART_TypeDef* USARTx, uint16_t Data)
|
||
//{
|
||
// RS485_TX_EN;
|
||
// Delayus(200);
|
||
// USART_SendData(USARTx, Data);
|
||
// while (!USART_GetFlagStatus(USART1,USART_FLAG_TC));
|
||
// RS485_RX_EN;
|
||
//}
|
||
|
||
////中断处理函数
|
||
//void USART1_IRQHandler (void)
|
||
//{
|
||
// uint8_t res = 0;
|
||
// if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE) ==SET)
|
||
// {
|
||
// res=USART_ReceiveData(USART1);
|
||
// PushQueue(&RecQueue,res);
|
||
|
||
// }
|
||
// USART_ClearITPendingBit(USART1,USART_IT_RXNE);//清中断标志位
|
||
//}
|
||
////波特率设置程序
|
||
////void USART1_SET_Baudrate(u8 bound)
|
||
////{
|
||
//// switch(bound)
|
||
//// {
|
||
//// case 0:
|
||
//// USART1_Config(SET_BAUDRATE_9600);
|
||
//// break;
|
||
//// case 1:
|
||
//// USART1_Config(SET_BAUDRATE_38400);
|
||
//// break;
|
||
//// case 2:
|
||
//// USART1_Config(SET_BAUDRATE_57600);
|
||
//// break;
|
||
//// case 3:
|
||
//// USART1_Config(SET_BAUDRATE_115200);
|
||
//// break;
|
||
//// default:break;
|
||
//// }
|
||
////}
|
||
////串口2配置 2022.2.7
|
||
////void USART2_Init(u32 bound)
|
||
////{
|
||
//// //初始化结构体 2022.2.7
|
||
//// GPIO_InitTypeDef GPIO_InitStructure;
|
||
//// USART_InitTypeDef USART_InitStructure;
|
||
//// NVIC_InitTypeDef NVIC_InitStructure;
|
||
//// //|RCC_APB2Periph_AFIO
|
||
//// RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); //使能GPIOA时钟
|
||
//// RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE); //使能USART2时钟
|
||
////
|
||
//// GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_2 | GPIO_Pin_3); //USART2对应的TX，RX,引脚 PA2 PA3
|
||
//// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //复用模式
|
||
//// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
//// GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
|
||
//// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
|
||
//// GPIO_Init(GPIOA, &GPIO_InitStructure);
|
||
////
|
||
//// //GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_11); //测试端口PA11 22.3.15
|
||
//// //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
|
||
//// //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
//// //GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
|
||
//// //GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
|
||
//// //GPIO_Init(GPIOA, &GPIO_InitStructure);
|
||
////
|
||
//// //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA2
|
||
//// //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽
|
||
//// //GPIO_Init(GPIOA, &GPIO_InitStructure);
|
||
////
|
||
//// //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3
|
||
//// //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
|
||
//// //GPIO_Init(GPIOA, &GPIO_InitStructure);
|
||
////
|
||
//// //RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,ENABLE);//复位串口2
|
||
//// //RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,DISABLE);//停止复位
|
||
////
|
||
//// //配置复用功能
|
||
//// GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_7);
|
||
//// GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_7);
|
||
////
|
||
//// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级 0-3;
|
||
//// NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //使能串口2中断
|
||
//// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; //先占优先级2级
|
||
//// NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //从优先级2级
|
||
//// NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
|
||
//// NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
|
||
////
|
||
//// USART_InitStructure.USART_BaudRate = bound;//波特率设置
|
||
//// USART_InitStructure.USART_WordLength = USART_WordLength_8b;//8位数据长度
|
||
//// USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
|
||
//// USART_InitStructure.USART_Parity = USART_Parity_No;///奇偶校验位
|
||
//// USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
|
||
//// USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式
|
||
////
|
||
//// //USART_DeInit(USART2);
|
||
//// USART_Init(USART2, &USART_InitStructure); //初始化串口
|
||
//// USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //开启中断
|
||
//// //USART_ClearFlag(USART2,USART_FLAG_TC); //清除接收标志
|
||
//// USART_Cmd(USART2, ENABLE); //使能串口
|
||
////}
|
||
// /**
|
||
//* USART2发送len个字节.
|
||
//* buf:发送区首地址
|
||
//* len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
|
||
//**/
|
||
////void USART2_Send_Data(u8 *buf,u16 len)
|
||
////{
|
||
//// u16 t;
|
||
//// for(t=0;t<len;t++) //循环发送数据
|
||
//// {
|
||
//// while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
|
||
//// USART_SendData(USART2,buf[t]);
|
||
//// }
|
||
//// while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
|
||
////}
|
||
///**
|
||
//* 这也是一个接收函数，可以用，也可以用下面main函数的方法调用
|
||
//* USART2查询接收到的数据
|
||
//* buf:接收缓存首地址
|
||
//* len:读到的数据长度
|
||
//**/
|
||
///*void USART2_Receive_Data(u8 *buf)
|
||
//{
|
||
// u8 rxlen=USART2_RX_CNT;
|
||
// u8 i=0;
|
||
// delay_ms(10); //等待10ms,连续超过10ms没有接收到一个数据,则认为接收结束
|
||
// while(rxlen!=USART2_RX_CNT)
|
||
// {
|
||
// rxlen=USART2_RX_CNT;
|
||
// delay_ms(10);
|
||
// }
|
||
// for(i=0;i<(USART2_RX_CNT);i++)
|
||
// {
|
||
// buf[i] = USART2_RX_BUF[i];
|
||
// USART2_RX_BUF[i] = 0;
|
||
// }
|
||
// USART2_RX_CNT=0; //清零
|
||
//}*/
|
||
|
||
////void USART2_SendStr(USART_TypeDef* USARTx, uint8_t *PData,uint8_t Datalen)
|
||
////{
|
||
//// unsigned char i=0;
|
||
//// for(;i< Datalen;i++)
|
||
//// {
|
||
//// USART_SendData(USARTx, *(PData+i));
|
||
//// while (!USART_GetFlagStatus(USARTx,USART_FLAG_TC));
|
||
//// }
|
||
////}
|
||
////
|
||
////void USART2_SentByte(USART_TypeDef* USARTx, uint16_t Data)
|
||
////{
|
||
//// USART_SendData(USARTx, Data);
|
||
//// while (!USART_GetFlagStatus(USARTx,USART_FLAG_TC));
|
||
////}
|
||
|
||
////void USART2_IRQHandler(void)
|
||
////{
|
||
//// u8 res;
|
||
//// if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收到数据
|
||
//// {
|
||
//// res = USART_ReceiveData(USART2); //读取接收到的数据
|
||
//// PushQueue(&UART2RecQueue,res);
|
||
//// //if(USART2_RX_STA==0)
|
||
//// //{
|
||
//// // USART2_RX_BUF[USART2_RX_CNT] = res; //记录接收到的值
|
||
//// // //当数据结尾收到0xA0和0xA1代表数据接收完成，是一串完整的数据
|
||
//// // if(USART2_RX_BUF[USART2_RX_CNT-1]==0xA0&&USART2_RX_BUF[USART2_RX_CNT]==0xA1)
|
||
//// // USART2_RX_STA=1;//表示接收数据结束
|
||
//// // USART2_RX_CNT++; //接收数据增加1
|
||
//// //}
|
||
//// }
|
||
//// //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题 22.4.20
|
||
//// //if(USART_GetFlagStatus(USART2,USART_FLAG_ORE) == SET)
|
||
//// //{
|
||
//// // USART_ReceiveData(USART2);
|
||
//// // USART_ClearFlag(USART2,USART_FLAG_ORE);
|
||
//// //}
|
||
//// USART_ClearFlag(USART2,USART_IT_RXNE); //一定要清除接收中断
|
||
////}
|
||
|
||
////2022.02.07 串口3初始化
|
||
////void USART3_Init(u32 baud)
|
||
////{
|
||
//// USART_InitTypeDef USART_InitStructure;
|
||
//// NVIC_InitTypeDef NVIC_InitStructure;
|
||
//// GPIO_InitTypeDef GPIO_InitStructure; //声明一个结构体变量，用来初始化GPIO
|
||
//// //使能串口的RCC时钟
|
||
//// RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB , ENABLE); //使能UART3所在GPIOB的时钟
|
||
//// RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
|
||
////
|
||
//// GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_10 | GPIO_Pin_11); //USART1对应的TX，RX,引脚 PB6 PB7
|
||
//// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; //复用模式
|
||
//// GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
//// GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽
|
||
//// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
|
||
//// GPIO_Init(GPIOB, &GPIO_InitStructure);
|
||
//// //串口使用的GPIO口配置
|
||
//// // Configure USART3 Rx (PB.11) as input floating
|
||
//// //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
|
||
//// //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
|
||
//// //GPIO_Init(GPIOB, &GPIO_InitStructure);
|
||
////
|
||
//// // Configure USART3 Tx (PB.10) as alternate function push-pull
|
||
//// //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
|
||
//// //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
|
||
//// //GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
|
||
//// //GPIO_Init(GPIOB, &GPIO_InitStructure);
|
||
//// //配置复用功能
|
||
//// GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_7);
|
||
//// GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_7);
|
||
////
|
||
//// //配置串口
|
||
//// USART_InitStructure.USART_BaudRate = baud;
|
||
//// USART_InitStructure.USART_WordLength = USART_WordLength_8b;
|
||
//// USART_InitStructure.USART_StopBits = USART_StopBits_1;
|
||
//// USART_InitStructure.USART_Parity = USART_Parity_No;
|
||
//// USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
|
||
//// USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
|
||
////
|
||
//// // Configure USART3
|
||
////
|
||
//// USART_Init(USART3, &USART_InitStructure);//配置串口3
|
||
//// // Enable USART3 Receive interrupts 使能串口接收中断
|
||
//// USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
|
||
//// // Enable the USART3
|
||
//// USART_Cmd(USART3, ENABLE);//使能串口3
|
||
////
|
||
//// //串口中断配置
|
||
//// //Configure the NVIC Preemption Priority Bits
|
||
//// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
|
||
////
|
||
//// // Enable the USART3 Interrupt
|
||
//// NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
|
||
//// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
|
||
//// NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2; //子优先级3
|
||
//// NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
|
||
//// NVIC_Init(&NVIC_InitStructure);
|
||
////
|
||
////
|
||
////
|
||
////}
|
||
|
||
////void USART3_Sned_Char(u8 temp)
|
||
////{
|
||
//// USART_SendData(USART3,(u8)temp);
|
||
//// while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)==RESET);
|
||
////}
|
||
|
||
////void USART3_Sned_Char_Buff(u8 buf[],u32 len)
|
||
////{
|
||
//// u32 i;
|
||
//// for(i=0;i<len;i++)
|
||
//// USART3_Sned_Char(buf[i]);
|
||
////}
|
||
|
||
////void USART3_IRQHandler(void) //串口3中断服务程序
|
||
////{
|
||
//// u8 Res;
|
||
//// if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
|
||
//// {
|
||
//// //USART3_RX_TIMEOUT=0;
|
||
//// //USART3_RX_BUF[USART3_RX_CNT++] = USART_ReceiveData(USART3); //读取接收到的数据
|
||
//// Res = USART_ReceiveData(USART3);
|
||
//// PushQueue(&UART3RecQueue,Res);
|
||
//// }
|
||
//// //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
|
||
//// if(USART_GetFlagStatus(USART3,USART_FLAG_ORE) == SET)
|
||
//// {
|
||
//// USART_ReceiveData(USART3);
|
||
//// USART_ClearFlag(USART3,USART_FLAG_ORE);
|
||
//// }
|
||
//// USART_ClearITPendingBit(USART3, USART_IT_RXNE);
|
||
////}
|
||
//
|