/************************************* 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;iISR & 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