支持多串口的模拟串口代码

  • A+
所属分类：技术教程

运行在AVR上，把变量封装在结构体，在用结构体指针来访问，还可以无限扩展UART数量呢。

  1. #include <iom32v.h>
  2. #include <macros.h>
  3. #include <string.h>
  4. #include "Vga_drv.h"
  5. #include "uart.h"
  6. #include "Key_Scan.h"
  7. #include "bmp.h"
  8. #include "Isr.h"
  9. #include "ps2_driver.h"
  10. #include "eeprom.h"
  11. #include "global.h"
  12. #include "CRC.h"
  13. #define uint32 unsigned long
  14. #define SC_RXD 6
  15. #define SC_RXD_SET_INPUT() {DDRD&=(~BIT(SC_RXD));}
  16. #define SC_RXD_GET() ((PIND&(BIT(SC_RXD))))
  17. #define SC_TXD 7
  18. #define SC_TXD_0() {PORTD&=(~BIT(SC_TXD));}
  19. #define SC_TXD_1() {PORTD|=BIT(SC_TXD);}
  20. #define SC_TXD_SET_OUTPUT() {DDRD|=BIT(SC_TXD);}
  21. uint8 sc1_rxd_scan_ct=0;
  22. uint8 sc1_rxd_scan_next_time=0;
  23. uint8 sc1_rxd_scan_step=0;
  24. uint8 sc1_rxd_dat;
  25. uint8 sc1_rxd_ready=0;
  26. uint8 sc1_rxd_tmpdat;
  27. uint8 sc_txd_ready=0;//模拟串口变量
  28. uint8 sc_txd_bit_pt=0;
  29. uint8 sc_txd_data=0;
  30. uint8 sc_txd_ct=0;
  31. void SC_Recv_Pro(uint8 dat){
  32. }
  33. void SC_RxdSrv(void){
  35.         if(sc1_rxd_scan_step==0){
  36.                 if(!SC_RXD_GET()){
  37.                         sc1_rxd_scan_step=1;
  38.                         return;
  39.                 }
  40.         }
  41.         if(sc1_rxd_scan_step==1){
  42.                 if(!SC_RXD_GET()){
  43.                         sc1_rxd_scan_step=2;                //rxd start bit ok,goto next step
  44.                         sc1_rxd_scan_ct=0;
  45.                         sc1_rxd_scan_next_time=3;
  46.                         sc1_rxd_tmpdat=0;
  47.                         return;
  48.                 }
  49.                 else{
  50.                         sc1_rxd_scan_step=0;        //rxd start bit is avalid
  51.                         return;
  52.                 }
  53.         }
  54.         if(sc1_rxd_scan_step>=2){
  55.                 sc1_rxd_scan_ct++;
  56.                 if(sc1_rxd_scan_ct<sc1_rxd_scan_next_time) return;
  57.                 sc1_rxd_scan_ct=0;
  59.                 if(sc1_rxd_scan_step<10){
  61.                         sc1_rxd_tmpdat>>=1;
  62.                         if(SC_RXD_GET()){
  63.                                 sc1_rxd_tmpdat|=0x80;
  64.                         }
  65.                         sc1_rxd_scan_step++;
  66.                         return;
  67.                 }
  68.                 if(sc1_rxd_scan_step==10){
  69.                         if(SC_RXD_GET()){
  70.                                 sc1_rxd_dat=sc1_rxd_tmpdat;
  71.                                 sc1_rxd_ready=1;
  72.                                 //Receive a byte OK
  73.                                 #if 0
  74.                                  sc_txd_data=sc1_rxd_dat;
  75.                                  sc_txd_ready=1;
  76.                                  #endif
  77.                                  #if 0
  78.                                  Test_Uart1(sc1_rxd_dat);
  79.                                  #endif
  80.                                  SC_Recv_Pro(sc1_rxd_dat);
  81.                         }
  82.                         sc1_rxd_scan_step=0;
  83.                         return;
  84.                 }
  87.         }
  88. }
  89. void SC_TxdSrv(void){
  90.         sc_txd_ct++;
  91.         if(sc_txd_ct<3) return;
  92.         sc_txd_ct=0;
  93.         if(sc_txd_ready){                                                        //Data Ready
  94.                 if(sc_txd_bit_pt<10){
  95.                         if(sc_txd_bit_pt==0){
  96.                                 SC_TXD_0();                                //Start BIT
  98.                         }
  99.                         else{
  101.                                 if(sc_txd_bit_pt>=9){
  102.                                         SC_TXD_1();                        //End BIT
  103.                                 }
  104.                                 else{                                                        //数据位
  105.                                         if((sc_txd_data>>(sc_txd_bit_pt-1))&0x01){
  106.                                                 SC_TXD_1();
  107.                                         }
  108.                                         else{
  109.                                                 SC_TXD_0();
  110.                                         }
  111.                                 }
  112.                         }
  113.                 }
  114.                 if(sc_txd_bit_pt>10){
  115.                         sc_txd_bit_pt=0;                        //发送完后延时两个时钟，复位各标志
  116.                         sc_txd_ready=0;
  117.                 }
  118.                 else{
  119.                         sc_txd_bit_pt++;                        //位指针自加
  120.                 }
  121.         }
  123. }
  124. void SC_send_char(uint8 b){
  125.          sc_txd_data=b;
  126.          sc_txd_ready=1;
  127.          while(sc_txd_ready==1);
  128. }
  129. void SC_send_str(uint8 *str){
  130.          while((*str)!=0){
  131.                  SC_send_char(*str);
  132.                 str++;
  133.          }
  134. }
  135. void init_SimComIO(void){
  136.         SC_TXD_SET_OUTPUT();
  137.         SC_TXD_1();
  138.         SC_RXD_SET_INPUT();
  139. }
  140. #pragma interrupt_handler ISR_T1:8
  141. void ISR_T1(void)
  142. {
  143. //compare occured TCNT1=OCR1A
  144.         SC_RxdSrv();
  145.         SC_TxdSrv();
  146. }

 

结构体封装多串口

  1. typedef sim_uart_def{
  2. uint8 sc1_rxd_scan_ct;
  3. uint8 sc1_rxd_scan_next_time;
  4. uint8 sc1_rxd_scan_step;
  5. uint8 sc1_rxd_dat;
  6. uint8 sc1_rxd_ready;
  7. uint8 sc1_rxd_tmpdat;
  8. uint8 sc_txd_ready;//模拟串口变量
  9. uint8 sc_txd_bit_pt;
  10. uint8 sc_txd_data;
  11. uint8 sc_txd_ct;
  12. }TYPE_SIM_UART_DEF;
  13. TYPE_SIM_UART_DEF su1,su2,su3,su4,su5,su6;
  14. void SC_RxdSrv(TYPE_SIM_UART_DEF *pSU);
  15. void SC_TxdSrv(TYPE_SIM_UART_DEF *pSU);
图片引用自网络
1 2 3