#include "main.h" #define DEBUG_IS_UARTX UART0 int fputc(int ch, FILE *f){UART_WriteByte(DEBUG_IS_UARTX, ch);while(UART_IsTXBusy(DEBUG_IS_UARTX)){;}return ch;} ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #define UART0_BUFF_MAX 256 #pragma pack (4) /*指定按4字节对齐*/ uint8_t cmd0_buf[UART0_BUFF_MAX]; uint8_t uart0_buf[UART0_BUFF_MAX]; #pragma pack () /*取消指定对齐，恢复缺省对齐*/ __IO uint32_t cmd0_length=0; __IO uint8_t cmd0_active=0; __IO uint32_t uart0_index=0; void uart0_putchar(uint8_t ch){while(UART_IsTXFIFOFull(UART0)){;}UART0->DATA=ch;} //void uart0_putchar(uint8_t ch){UART_WriteByte(UART0, ch);while(UART_IsTXBusy(UART0)){;}} void uart0_putbuf(uint8_t *buf,uint32_t len){while(len--){uart0_putchar(*buf++);}} void uart0_puts(char *str){while(*str){uart0_putchar((int)*str++);}} uint32_t uart0_getbuf(uint8_t *buf){while(!cmd0_active){DelayMs(1);} memcpy(buf,cmd0_buf,cmd0_length);cmd0_active=0;return cmd0_length;} void UART0_Init(void) { UART_InitStructure UART_initStruct; PORT_Init(PORTC, PIN12, PORTC_PIN12_UART0_RX, 1); // GPIOC.12 配置为 UART0 输入引脚 PORT_Init(PORTC, PIN13, PORTC_PIN13_UART0_TX, 0); // GPIOC.13 配置为 UART0 输出引脚 UART_initStruct.Baudrate = 115200; UART_initStruct.DataBits = UART_DATA_8BIT; //数据位位数，可取值UART_DATA_8BIT、UART_DATA_9BIT UART_initStruct.Parity = UART_PARITY_NONE; //奇偶校验位，可取值UART_PARITY_NONE、UART_PARITY_ODD、UART_PARITY_EVEN、UART_PARITY_ONE、UART_PARITY_ZERO UART_initStruct.StopBits = UART_STOP_1BIT; //停止位位数，可取值UART_STOP_1BIT、UART_STOP_2BIT UART_initStruct.TXThreshold = 7; //取值0--7 UART_initStruct.TXThresholdIEn = 0; //当TX FIFO中数据个数 <= TXThreshold时触发中断 UART_initStruct.RXThreshold = 7; //取值0--7 UART_initStruct.RXThresholdIEn = 1; //当RX FIFO中数据个数 >= RXThreshold时触发中断 UART_initStruct.TimeoutTime = 20; //超时时长 = TimeoutTime/(Baudrate/10) 秒 = 20/11520 = 1.736 MS UART_initStruct.TimeoutIEn = 1; //超时中断，超过 TimeoutTime/(Baudrate/10) 秒没有在RX线上接收到数据时触发中断 UART_Init(UART0, &UART_initStruct); NVIC_SetPriority(UART0_IRQn, 1); UART_Open(UART0); } void UART0_Handler(void) { uint32_t tmp; if(UART_INTStat(UART0, UART_IT_RX_THR))//阈值中断 { UART_INTClr(UART0, UART_IT_RX_THR); //uart0_putchar('*');//测试阈值中断 for(uint32_t i=0;i<6;i++) //读取6个字节，留1个给超时中断再读，否则缓冲空了产生不了超时中断 { if(UART_ReadByte(UART0, &tmp) == 0) { if(uart0_index>=UART0_BUFF_MAX){uart0_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart0_buf[uart0_index++] = tmp; //读取字符 } else{uart0_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } } if(UART_INTStat(UART0, UART_IT_RX_TOUT))//超时中断 { UART_INTClr(UART0, UART_IT_RX_TOUT); //uart0_putchar('#');//测试超时中断 while(UART_IsRXFIFOEmpty(UART0) == 0) { if(UART_ReadByte(UART0, &tmp) == 0) { if(uart0_index>=UART0_BUFF_MAX){uart0_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart0_buf[uart0_index++] = tmp; //读取字符 } else{uart0_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } memcpy(cmd0_buf, uart0_buf, uart0_index); //超时了，就是数据包结束了，取走全部数据 cmd0_length=uart0_index;uart0_index=0;cmd0_active=1; //取走接收数据长度并重新把接收指针指向缓冲开始，表明数据有效 } } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #define UART1_BUFF_MAX 256 #pragma pack (4) /*指定按4字节对齐*/ uint8_t cmd1_buf[UART1_BUFF_MAX]; uint8_t uart1_buf[UART1_BUFF_MAX]; #pragma pack () /*取消指定对齐，恢复缺省对齐*/ __IO uint32_t cmd1_length=0; __IO uint8_t cmd1_active=0; __IO uint32_t uart1_index=0; void uart1_putchar(uint8_t ch){while(UART_IsTXFIFOFull(UART1)){;}UART1->DATA=ch;} //void uart1_putchar(uint8_t ch){UART_WriteByte(UART1, ch);while(UART_IsTXBusy(UART1)){;}} void uart1_putbuf(uint8_t *buf,uint32_t len){while(len--){uart1_putchar(*buf++);}} void uart1_puts(char *str){while(*str){uart1_putchar((int)*str++);}} uint32_t uart1_getbuf(uint8_t *buf){while(!cmd1_active){DelayMs(1);} memcpy(buf,cmd1_buf,cmd1_length);cmd1_active=0;return cmd1_length;} void UART1_Init(void) { UART_InitStructure UART_initStruct; PORT_Init(PORTD, PIN4 , PORTD_PIN4_UART1_RX, 1); //GPIOD.4 配置为 UART1 输入引脚 PORT_Init(PORTD, PIN3 , PORTD_PIN3_UART1_TX, 0); //GPIOD.3 配置为 UART1 输出引脚 UART_initStruct.Baudrate = 115200; UART_initStruct.DataBits = UART_DATA_8BIT; //数据位位数，可取值UART_DATA_8BIT、UART_DATA_9BIT UART_initStruct.Parity = UART_PARITY_NONE; //奇偶校验位，可取值UART_PARITY_NONE、UART_PARITY_ODD、UART_PARITY_EVEN、UART_PARITY_ONE、UART_PARITY_ZERO UART_initStruct.StopBits = UART_STOP_1BIT; //停止位位数，可取值UART_STOP_1BIT、UART_STOP_2BIT UART_initStruct.TXThreshold = 7; //取值0--7 UART_initStruct.TXThresholdIEn = 0; //当TX FIFO中数据个数 <= TXThreshold时触发中断 UART_initStruct.RXThreshold = 7; //取值0--7 UART_initStruct.RXThresholdIEn = 1; //当RX FIFO中数据个数 >= RXThreshold时触发中断 UART_initStruct.TimeoutTime = 20; //超时时长 = TimeoutTime/(Baudrate/10) 秒 = 20/11520 = 1.736 MS UART_initStruct.TimeoutIEn = 1; //超时中断，超过 TimeoutTime/(Baudrate/10) 秒没有在RX线上接收到数据时触发中断 UART_Init(UART1, &UART_initStruct); NVIC_SetPriority(UART1_IRQn, 2); UART_Open(UART1); } #if UART1_IS_LIN #else void UART1_Handler(void) { uint32_t tmp; if(UART_INTStat(UART1, UART_IT_RX_THR))//阈值中断 { UART_INTClr(UART1, UART_IT_RX_THR); uart1_putchar('*');//测试阈值中断 for(uint32_t i=0;i<6;i++) //读取6个字节，留1个给超时中断再读，否则缓冲空了产生不了超时中断 { if(UART_ReadByte(UART1, &tmp) == 0) { if(uart1_index>=UART1_BUFF_MAX){uart1_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart1_buf[uart1_index++] = tmp; //读取字符 } else{uart1_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } } if(UART_INTStat(UART1, UART_IT_RX_TOUT))//超时中断 { UART_INTClr(UART1, UART_IT_RX_TOUT); uart1_putchar('#');//测试超时中断 while(UART_IsRXFIFOEmpty(UART1) == 0) { if(UART_ReadByte(UART1, &tmp) == 0) { if(uart1_index>=UART1_BUFF_MAX){uart1_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart1_buf[uart1_index++] = tmp; //读取字符 } else{uart1_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } memcpy(cmd1_buf, uart1_buf, uart1_index); //超时了，就是数据包结束了，取走全部数据 cmd1_length=uart1_index;uart1_index=0;cmd1_active=1; //取走接收数据长度并重新把接收指针指向缓冲开始，表明数据有效 } } #endif ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #define UART2_BUFF_MAX 256 #pragma pack (4) /*指定按4字节对齐*/ uint8_t cmd2_buf[UART2_BUFF_MAX]; uint8_t uart2_buf[UART2_BUFF_MAX]; #pragma pack () /*取消指定对齐，恢复缺省对齐*/ __IO uint32_t cmd2_length=0; __IO uint8_t cmd2_active=0; __IO uint32_t uart2_index=0; void uart2_putchar(uint8_t ch){while(UART_IsTXFIFOFull(UART2)){;}UART2->DATA=ch;} //void uart2_putchar(uint8_t ch){UART_WriteByte(UART2, ch);while(UART_IsTXBusy(UART2)){;}} void uart2_putbuf(uint8_t *buf,uint32_t len){while(len--){uart2_putchar(*buf++);}} void uart2_puts(char *str){while(*str){uart2_putchar((int)*str++);}} uint32_t uart2_getbuf(uint8_t *buf){while(!cmd2_active){DelayMs(1);} memcpy(buf,cmd2_buf,cmd2_length);cmd2_active=0;return cmd2_length;} void UART2_Init(void) { UART_InitStructure UART_initStruct; PORT_Init(PORTC, PIN1, PORTC_PIN1_UART2_RX, 1); //GPIOC.1 配置为 UART2 输入引脚 PORT_Init(PORTC, PIN0, PORTC_PIN0_UART2_TX, 0); //GPIOC.0 配置为 UART2 输出引脚 UART_initStruct.Baudrate = 115200; UART_initStruct.DataBits = UART_DATA_8BIT; //数据位位数，可取值UART_DATA_8BIT、UART_DATA_9BIT UART_initStruct.Parity = UART_PARITY_NONE; //奇偶校验位，可取值UART_PARITY_NONE、UART_PARITY_ODD、UART_PARITY_EVEN、UART_PARITY_ONE、UART_PARITY_ZERO UART_initStruct.StopBits = UART_STOP_1BIT; //停止位位数，可取值UART_STOP_1BIT、UART_STOP_2BIT UART_initStruct.TXThreshold = 7; //取值0--7 UART_initStruct.TXThresholdIEn = 0; //当TX FIFO中数据个数 <= TXThreshold时触发中断 UART_initStruct.RXThreshold = 7; //取值0--7 UART_initStruct.RXThresholdIEn = 1; //当RX FIFO中数据个数 >= RXThreshold时触发中断 UART_initStruct.TimeoutTime = 20; //超时时长 = TimeoutTime/(Baudrate/10) 秒 = 20/11520 = 1.736 MS UART_initStruct.TimeoutIEn = 1; //超时中断，超过 TimeoutTime/(Baudrate/10) 秒没有在RX线上接收到数据时触发中断 UART_Init(UART2, &UART_initStruct); NVIC_SetPriority(UART2_IRQn, 3); UART_Open(UART2); } void UART2_Handler(void) { uint32_t tmp; if(UART_INTStat(UART2, UART_IT_RX_THR))//阈值中断 { UART_INTClr(UART2, UART_IT_RX_THR); //uart2_putchar('*');//测试阈值中断 for(uint32_t i=0;i<6;i++) //读取6个字节，留1个给超时中断再读，否则缓冲空了产生不了超时中断 { if(UART_ReadByte(UART2, &tmp) == 0) { if(uart2_index>=UART2_BUFF_MAX){uart2_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart2_buf[uart2_index++] = tmp; //读取字符 } else{uart2_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } } if(UART_INTStat(UART2, UART_IT_RX_TOUT))//超时中断 { UART_INTClr(UART2, UART_IT_RX_TOUT); //uart2_putchar('#');//测试超时中断 while(UART_IsRXFIFOEmpty(UART2) == 0) { if(UART_ReadByte(UART2, &tmp) == 0) { if(uart2_index>=UART2_BUFF_MAX){uart2_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart2_buf[uart2_index++] = tmp; //读取字符 } else{uart2_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } memcpy(cmd2_buf, uart2_buf, uart2_index); //超时了，就是数据包结束了，取走全部数据 cmd2_length=uart2_index;uart2_index=0;cmd2_active=1; //取走接收数据长度并重新把接收指针指向缓冲开始，表明数据有效 } } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #define UART3_BUFF_MAX 256 #pragma pack (4) /*指定按4字节对齐*/ uint8_t cmd3_buf[UART3_BUFF_MAX]; uint8_t uart3_buf[UART3_BUFF_MAX]; #pragma pack () /*取消指定对齐，恢复缺省对齐*/ __IO uint32_t cmd3_length=0; __IO uint8_t cmd3_active=0; __IO uint32_t uart3_index=0; void uart3_putchar(uint8_t ch){while(UART_IsTXFIFOFull(UART3)){;}UART3->DATA=ch;} //void uart3_putchar(uint8_t ch){UART_WriteByte(UART3, ch);while(UART_IsTXBusy(UART3)){;}} void uart3_putbuf(uint8_t *buf,uint32_t len){while(len--){uart3_putchar(*buf++);}} void uart3_puts(char *str){while(*str){uart3_putchar((int)*str++);}} uint32_t uart3_getbuf(uint8_t *buf){while(!cmd3_active){DelayMs(1);} memcpy(buf,cmd3_buf,cmd3_length);cmd3_active=0;return cmd3_length;} void UART3_Init(void) { UART_InitStructure UART_initStruct; PORT_Init(PORTC, PIN2, PORTC_PIN2_UART3_RX, 1); //GPIOC.2 配置为 UART3 输入引脚 PORT_Init(PORTC, PIN3, PORTC_PIN3_UART3_TX, 0); //GPIOC.3 配置为 UART3 输出引脚 UART_initStruct.Baudrate = 115200; UART_initStruct.DataBits = UART_DATA_8BIT; //数据位位数，可取值UART_DATA_8BIT、UART_DATA_9BIT UART_initStruct.Parity = UART_PARITY_NONE; //奇偶校验位，可取值UART_PARITY_NONE、UART_PARITY_ODD、UART_PARITY_EVEN、UART_PARITY_ONE、UART_PARITY_ZERO UART_initStruct.StopBits = UART_STOP_1BIT; //停止位位数，可取值UART_STOP_1BIT、UART_STOP_2BIT UART_initStruct.TXThreshold = 7; //取值0--7 UART_initStruct.TXThresholdIEn = 0; //当TX FIFO中数据个数 <= TXThreshold时触发中断 UART_initStruct.RXThreshold = 7; //取值0--7 UART_initStruct.RXThresholdIEn = 1; //当RX FIFO中数据个数 >= RXThreshold时触发中断 UART_initStruct.TimeoutTime = 20; //超时时长 = TimeoutTime/(Baudrate/10) 秒 = 20/11520 = 1.736 MS UART_initStruct.TimeoutIEn = 1; //超时中断，超过 TimeoutTime/(Baudrate/10) 秒没有在RX线上接收到数据时触发中断 UART_Init(UART3, &UART_initStruct); NVIC_SetPriority(UART3_IRQn, 4); UART_Open(UART3); } void UART3_Handler(void) { uint32_t tmp; if(UART_INTStat(UART3, UART_IT_RX_THR))//阈值中断 { UART_INTClr(UART3, UART_IT_RX_THR); for(uint32_t i=0;i<6;i++) //读取6个字节，留1个给超时中断再读，否则缓冲空了产生不了超时中断 { //printf("#"); if(UART_ReadByte(UART3, &tmp) == 0) { if(uart3_index>=UART3_BUFF_MAX){uart3_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart3_buf[uart3_index++] = tmp; //读取字符 } else{uart3_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } }else if(UART_INTStat(UART3, UART_IT_RX_TOUT))//超时中断 { UART_INTClr(UART3, UART_IT_RX_TOUT); while(UART_IsRXFIFOEmpty(UART3) == 0) { //printf("*"); if(UART_ReadByte(UART3, &tmp) == 0) { if(uart3_index>=UART3_BUFF_MAX){uart3_index=0;} //防止缓冲溢出重新把接收指针指向缓冲开始 uart3_buf[uart3_index++] = tmp; //读取字符 } else{uart3_index=0;} //字符出错丢弃后重新把接收指针指向缓冲开始 } memcpy(cmd3_buf, uart3_buf, uart3_index); //超时了，就是数据包结束了，取走全部数据 cmd3_length=uart3_index;uart3_index=0;cmd3_active=1; //取走接收数据长度并重新把接收指针指向缓冲开始，表明数据有效 } else { //printf("EEE%x %x\n\r",UART3->CTRL,UART3->DATA); } } void uart_test(void) { char combuf[512]; if(cmd0_active) { uint8_t len=uart0_getbuf((uint8_t*)combuf); //for(int i=0;i