GPIO模拟UART串口时序

怼烎@ 2022-05-26 13:07 472阅读 0赞

GPIO模拟UART串口时序

模拟时序：

![Image 1][]

平台：Cortex-M0

![Image 1][]

与FPGA UART的区别：

FPGA发送、接收使用的是独立的时序，并行处理易于实现。而单片机只能使用定时器来模拟时序，并通过外部下降沿中断触发启动，实时性受到限制；对于实时性要求较高的应用，需要同时处理发送和接收时（全双工）1路UART需要使用2个定时器；而半双工应用可以只使用一个定时器即可实现。基于50MHZ的M0一般9600是可以实现的，在向上估计会不稳定。主要是应用于对于特定设计临时增加低速串口通信，降低成本。

示例代码：

V1.5：双定时器方案

1、myiouart.h+ myiouart.c

2、资源占用：1个输入中断+2个定时器（针对实时要求高的场合）

  1. myiouart.h:
  3. //<<< Use Configuration Wizard in Context Menu >>>
  4. #ifndef _MYIOUART_H_
  5. #define _MYIOUART_H_
  6. #include "LPC11xx.h"
  8. //<h> MyIouartConfig [2017.2.20]
  9. //<i>   注：双定时器模拟串口！CT32B0+CT32B1
  10.     //<o>ECHO <0=> No <1=> Yes
  11.     //<i>回显测试功能： 
  12.     //<i>打开回显功能后，模拟串口将自动返回自己所接收到的数据，仅作测试串口功能使用！
  13.     #define ENABLE_ECHO     0                     
  15.     //<o> COM_BAUDRATE <1200=> 1200 <9600=> 9600  <57600=> 57600  <115200=> 115200
  16.     //<i> 串口通讯波特率配置
  17.     //<i> 默认为9600!
  18.     #define IOUART_BAUDRATE    9600
  21. //</h>
  24. //--------------------------------------------------------------
  25. #define IOUART_RECV_NULL 0         //没有接收数据
  26. #define IOUART_RECV_OK 1           //接收数据成功返回值
  27. #define IOUART_RECV_WRONG_ST 11    //接收数据起始位出错返回值
  28. #define IOUART_RECV_WRONG_EN 12    //接收数据结束位出错返回值
  30. //
  31. #define   SET_UART_BAUD   48000000UL/(IOUART_BAUDRATE) //波特率设置
  32. #define   MyUart_STOPBITS 1
  36. //
  38. //config  iouart3
  39. #define  MyIOUART_TX_PORT      PIO2_8
  40. #define  MyIOUART_RX_PORT      PIO2_7
  41. #define  MyIOUART_TX_P         LPC_GPIO2
  42. #define  MyIOUART_RX_P         LPC_GPIO2
  43. #define  MyIOUART_TX_P_INDEX   8
  44. #define  MyIOUART_RX_P_INDEX   7
  45. //
  46. #define  MyIOUART_RX_IRQn   EINT2_IRQn
  49. //------------------------------------------
  51. extern char g_strtemp[32];    
  52. extern unsigned long g_rx_cnt;//For Debug. Record the count value of recieved bytes!
  53. extern unsigned long g_tx_cnt;//For Debug. Record the count value of sended bytes!
  56. //
  57. #define BUFFER_LEN 128
  59. //
  60. char* NumToStrEx(long Number,char*PStr,unsigned char Len);
  61. //FIFO Buffer
  62. void Iouart_FifoInit(void);
  63. unsigned char GetLen_RecvedData(void);
  64. unsigned char* GetTxbuf_RecvedData(void);
  65. unsigned char ReadByte_RxFiFo(void);
  66. int WriteByte_TxFifo(unsigned char *T,unsigned char len);//非阻塞
  68. //
  69. void put_char(char *cp);//阻塞
  70. void iouart1_send(char *pData,unsigned char pLen);//阻塞
  71. void print_dat(char sp[],char len);//阻塞
  72. //
  73. void IOUART1_Init(void);
  75. void Timer2Init(void);
  76. void Timer3Init(void);
  82. //--------------------------------------------------------------
  83. #endif
  84. // <<< end of configuration section >>>
  86. myiouart.c:
  88. #include "myiouart.h"
  89. //
  90. char g_strtemp[32]={0};    
  91. unsigned long g_rx_cnt = 0;//For Debug. Record the count value of recieved bytes!
  92. unsigned long g_tx_cnt = 0;//For Debug. Record the count value of sended bytes!
  94. //RX
  95. static volatile unsigned char l_recv_byte=0;
  96. static volatile unsigned char l_recv_st=0;
  97. static volatile unsigned char l_recv_cnt=8;
  99. //TX
  100. static volatile unsigned char l_send_byte=0;
  101. static volatile unsigned char l_send_st=0;
  102. static volatile unsigned char l_send_cnt=8;
  103. static volatile unsigned char l_send_style=0;//根据send_style判断是通过缓存发送还是直接发送
  105. //
  106. static volatile unsigned char l_channel=0;
  107. //
  108. //l=local g=global  
  109. //FIFO Buffer
  110. unsigned char l_Txbuffer[8+BUFFER_LEN]={0};
  111. volatile unsigned char l_Rxbuffer[8+BUFFER_LEN]={0};
  112. volatile unsigned char l_RxDataLen=0;
  113. volatile unsigned char l_RxWrongRecord[2+BUFFER_LEN]={0};//接收数据出错记录BUFFER
  114. //
  115. void Iouart_FifoInit(void)
  116. {
  117.     //仅记录一个BUFFER_LEN长度的接收错误记录
  118.     l_RxWrongRecord[0]=2;//sp:2->(2+BUFFER_LEN)-1
  119.     l_RxWrongRecord[1]=(2+BUFFER_LEN)-1;//end addr
  120.     //
  121.     l_RxDataLen=0;
  123.     //Rx
  124.     //接收数据的起始地址（使用相对地址从8->BUFFER_LEN-1）
  125.     l_Rxbuffer[0]=8;
  126.     l_Rxbuffer[1]=0;
  127.   //接收数据的结束地址
  128.     l_Rxbuffer[2]=8;
  129.     l_Rxbuffer[3]=0;
  130.     //Buffer的结束地址
  131.   l_Rxbuffer[4]=(BUFFER_LEN-1)+8;
  132.     l_Rxbuffer[5]=0;
  133.     //接收数据的长度
  134.     l_Rxbuffer[6]=0;
  135.     //Buffer的长度
  136.     l_Rxbuffer[7]=BUFFER_LEN;
  138.     //Tx
  139.     //Tx数据的起始地址
  140.     l_Txbuffer[0]=8;
  141.     l_Txbuffer[1]=0;
  142.   //Tx数据的结束地址
  143.     l_Txbuffer[2]=8;
  144.     l_Txbuffer[3]=0;
  145.     //Buffer的结束地址
  146.   l_Txbuffer[4]=(BUFFER_LEN-1)+8;
  147.     l_Txbuffer[5]=0;
  148.     //Tx数据的长度
  149.     l_Txbuffer[6]=0;
  150.     //Buffer的长度
  151.     l_Txbuffer[7]=BUFFER_LEN;
  153. }
  155. /*
  156. 获取Buffer中接收到的数据长度
  157. */
  158. unsigned char GetLen_RecvedData(void)
  159. {
  160.    return l_RxDataLen;
  161. }
  163. unsigned char* GetTxbuf_RecvedData(void)
  164. {
  165.    return l_Txbuffer;
  166. }
  167. /*
  168.  从模拟串口读取一个字节数据 
  169.  调用该函数前先判断GetRecvDataLen()返回值，否则在没有接收到数据时读到的数据为0
  170. */
  171. unsigned char ReadByte_RxFiFo(void)
  172. {
  173.     unsigned char Data0=0;
  174.     if(l_Rxbuffer[6])
  175.     {
  176.          Data0 = l_Rxbuffer[l_Rxbuffer[0]];
  177.          //
  178.          if(l_Rxbuffer[0]< l_Txbuffer[4])
  179.          {
  180.            l_Rxbuffer[0]++;
  181.          }
  182.          else
  183.          {
  184.              l_Rxbuffer[0]=8;
  185.          }
  186.          //
  187.          l_Rxbuffer[6]--;
  188.     }
  189.   //update rx len
  190.     l_RxDataLen=l_Rxbuffer[6];
  192.   return Data0;
  193. }
  195. /*
  196.  从模拟串口发送一个数据Buffer,属于一次性连续发送！
  197.  若发送缓冲区满返回-1
  198. */
  199. int WriteByte_TxFifo(unsigned char *T,unsigned char len)
  200. {
  201.   unsigned char i = 0;
  202.     if(len)
  203.     while(len--){
  204.     if(l_Txbuffer[6] < l_Txbuffer[7]) {
  205.      l_Txbuffer[6]++;//TxLength
  206.          l_Txbuffer[l_Txbuffer[2]]=T[i++];
  207.          if(l_Txbuffer[2]<l_Txbuffer[4])
  208.          {
  209.              l_Txbuffer[2]++;
  210.          }
  211.          else
  212.          {
  213.              l_Txbuffer[2]=8;
  214.          }
  215.      }
  216.      else
  217.    {
  218.      return -1;//发送缓冲区满
  219.    }    
  220.     }
  222.      //开启发送需设置5个变量
  223.      l_send_byte = l_Txbuffer[l_Txbuffer[0]];
  224.      l_send_cnt = 9;
  225.      l_send_style=1;    
  226.    LPC_TMR32B0->TCR = 1;
  227.      l_send_st=1;
  229.    //-----------
  230.    return 1;
  232. }
  236. /*
  237.   数字转字符串函数
  238. */
  239. char* NumToStrEx(long Number,char*PStr,unsigned char Len)
  240. {
  241.     unsigned long NumberT=0;
  242.     unsigned char Count=0;
  243.     if(Number<0)  
  244.     {
  245.         *PStr='-';
  246.         Number=-Number;
  247.         Count=1;
  248.     }
  249.     else if(Number==0)
  250.     {
  251.       *PStr='0';
  252.         *(PStr+1)=0;
  253.         return PStr;
  254.     }
  255.     NumberT=Number;
  256.     while(NumberT)
  257.     {
  258.             NumberT/=10;
  259.          Count++;
  260.     }
  261.     if(Len<=Count)  return 0;
  262.     //
  263.     *(PStr+Count--)=0;
  264.     //
  265.     while(Number)
  266.     {
  267.         *(PStr+Count--)='0'+Number%10;
  268.         Number/=10;
  269.     }
  270.     return PStr;
  271. }
  273. void put_char(char *cp)
  274. {
  275.     //LPC_GPIO2->IE &= ~(1<<7);LPC_GPIO2->IC=(1<<7); //NVIC_DisableIRQ(EINT2_IRQn);
  276.       //LPC_GPIO3->IE &= ~(1<<1);LPC_GPIO3->IC=(1<<1);
  277.       //---------------------------------------------
  279.         l_send_byte = *cp;    
  280.         l_send_cnt = 9;
  281.         l_send_style = 0;
  282.       l_send_st=1;
  283.         // LPC_TMR16B1->TCR = 1;//start counter 
  284.       LPC_TMR32B0->TCR = 1;//根据使用的定时器选择
  285.         while(l_send_st){}
  287.       //--------------------------------------------
  289.       //LPC_GPIO2->IE |= (1<<7);
  290.       //NVIC_EnableIRQ(EINT2_IRQn); 
  291.       //LPC_GPIO3->IE |= (1<<1);
  293. }
  296. /*
  297.     阻塞发送字符串，不使用缓存
  298. */
  299. void iouart1_send(char *pData,unsigned char pLen)
  300. {
  301.     while(pLen--)
  302.     {
  303.         put_char(pData++);
  304.     }
  305. }
  307. /*
  308.     阻塞发送数据，不使用缓存
  309. */
  310. void print_dat(char sp[],char len)
  311. {
  312.   LPC_GPIO0->DATA |= (1 << 7);//H    485TxMode
  313.     //-----------------------------------------
  314.     while(len--)
  315.     {
  316.         put_char(sp++);
  317.     }
  318.     //-----------------------------------------
  319.     LPC_GPIO0->DATA &= ~(1 << 7);    //L    485RxMode    
  320. }
  323. void IOUART1_Init(void)
  324. {
  325.     Iouart_FifoInit();
  326.     //
  327.     LPC_SYSCON->SYSAHBCLKCTRL |= (1ul << 6); 
  328.     //UART3 [channel=0] & 4852  EN--P0.7   RX--P2.7  TX--P2.8 
  329.     //TX PIO2_8
  330.     LPC_IOCON->MyIOUART_TX_PORT &= ~(0x07);    /*IO功能*/
  331.     MyIOUART_TX_P->DIR  |= (1 << MyIOUART_TX_P_INDEX);    /*Output*/
  332.     MyIOUART_TX_P->DATA |= (1 << MyIOUART_TX_P_INDEX);//H    
  333.     //RX  PIO2_7    
  334.     LPC_IOCON->MyIOUART_RX_PORT &= ~(0x07);//IO fucntion 
  335.     MyIOUART_RX_P->DIR &= ~(1<<MyIOUART_RX_P_INDEX);//Input
  336.     MyIOUART_RX_P->IS  &= ~(1<<MyIOUART_RX_P_INDEX);//edge sensitive
  337.     MyIOUART_RX_P->IEV &= ~(1<<MyIOUART_RX_P_INDEX);//falling edge 
  338.     MyIOUART_RX_P->IBE &= ~(1<<MyIOUART_RX_P_INDEX);//
  339.     //
  340.     NVIC_SetPriority(MyIOUART_RX_IRQn, 0);
  341.     NVIC_EnableIRQ(MyIOUART_RX_IRQn);
  342.     MyIOUART_RX_P->IC=(1<<MyIOUART_RX_P_INDEX);
  343.     MyIOUART_RX_P->IE |= (1<<MyIOUART_RX_P_INDEX);//enable interrupt
  345.     //sel uart chanel
  346.     l_channel=0;
  347.     g_rx_cnt=0;
  348.     g_tx_cnt=0;
  350.     //
  351.     Timer3Init();//CT32B1  For Rx!
  352.     Timer2Init();//CT32B0  For TX!
  353. }
  357. void RecvWrongSt(void)
  358. {        
  359.      //记录错误，并重新开启RX引脚接收中断
  360.      LPC_GPIO3->DATA &= ~(1 << 3);//L    
  361.      //Record wrong case.Just For Debug.
  362.      l_RxWrongRecord[l_RxWrongRecord[0]]=IOUART_RECV_WRONG_ST;
  363.      if(l_RxWrongRecord[0]<l_RxWrongRecord[1])
  364.      {
  365.          l_RxWrongRecord[0]++;
  366.      }
  367.      //         
  368.      MyIOUART_RX_P->IC |= (1<<MyIOUART_RX_P_INDEX);                 
  369.      MyIOUART_RX_P->IE |= (1<<MyIOUART_RX_P_INDEX);
  370.      return;        
  371. }
  373. void  recv_interrupt(void) //Just For Echo!
  374. {
  375.   //回显测试 
  376.   unsigned char len = l_RxDataLen;    
  377.     while(len--)
  378.     {
  379.     unsigned char t= ReadByte_RxFiFo();
  380.     WriteByte_TxFifo(&t,1);
  381.   }  
  382. }
  386. void PIOINT2_IRQHandler(void)//下降沿触发中断
  387. {
  388.   LPC_GPIO3->DATA |= (1 << 3);//H  //LED
  389.     //
  390.     if((MyIOUART_RX_P->DATA & (1<<MyIOUART_RX_P_INDEX)))//起始位电平(L)检测
  391.     {
  392.       RecvWrongSt();
  393.     return;
  394.     }
  395.     //
  396.     if(MyIOUART_RX_P->MIS&(1<<MyIOUART_RX_P_INDEX))//Rx 判断触发中断的引脚
  397.     {         
  398.        //
  399.            MyIOUART_RX_P->IE &= ~(1<<MyIOUART_RX_P_INDEX);//disable interrupt
  400.          MyIOUART_RX_P->IC |= (1<<MyIOUART_RX_P_INDEX);//clear interrupt flag
  401.            //
  402.            //
  403.            l_RxDataLen = 0;//接收过程禁止读取数据
  404.            l_recv_cnt = 8;
  405.              l_recv_st = 1;
  406.            // start recv
  407.        LPC_TMR32B1->TCR = 1;
  408.              LPC_TMR32B1->IR = 1;
  410.              //
  411.              //LPC_GPIO2->IC=(1<<7);//clear interrupt flag
  412.              //LPC_GPIO2->IE |= (1<<7);//enable interrupt
  413.              //NVIC_EnableIRQ(EINT2_IRQn);
  414.              //
  415.      }
  416.      //
  417.    LPC_GPIO3->DATA &= ~(1 << 3);//L    
  418. }
  421. //32位定时器  CT32B0/1  【注：32位定时器和16位定时器功能一样，仅仅将16改成32，并修改一下时钟使能位（C32B0=9;C32B1=10），即可】
  422. void Timer2Init(void)//CT32B0
  423. {
  424.   LPC_SYSCON->SYSAHBCLKCTRL    |= (1<<9); //enable ct32b1 clk 
  425.   LPC_TMR32B0->CTCR &= ~(3);//timer[function sel]
  426.     LPC_TMR32B0->MCR = 3;//enable interrupt and reset autoself
  427.     //-------------------------------------------------------------
  428.     LPC_TMR32B0->PR = 0;//16bits[max=2^16=65536]  48MHZ(sysahbclk)/48=1000KHZ
  429.     //IOuart要支持高的波特率，PR值要设置尽量小，然后不断调试MR0的值即可达要想要的波特率，一开始
  430.     //调试不成功就是因为PR设为了100太大，导致9600接收总是失败
  431.     //-------------------------------------------------------------
  432.     //One timer can gennerate four interrupts for MR0、MR1、MR2、MR3.
  433.     LPC_TMR32B0->MR0 = SET_UART_BAUD;
  434.     //--------------------------------------------------------------
  435.     LPC_TMR32B0->TCR = 2;//reset 
  436.     LPC_TMR32B0->IR =1;//clear interrupt flag
  437.     LPC_TMR32B0->TCR = 1;//load cfg of ct16b1
  438.     //
  439.     LPC_TMR32B0->TCR =2 ;//reset
  440.     LPC_TMR32B0->TCR =0 ;//stop counter
  442.     //
  443.     NVIC_EnableIRQ(TIMER_32_0_IRQn);    
  444.     NVIC_SetPriority(TIMER_32_0_IRQn,1);    
  446. }
  448. void Timer3Init(void)//CT32B1
  449. {
  450.     LPC_SYSCON->SYSAHBCLKCTRL    |= (1<<10); //enable ct32b1 clk 
  451.     LPC_TMR32B1->CTCR &= ~(3);//timer[function sel]
  452.     LPC_TMR32B1->MCR = 3;//enable interrupt and reset autoself
  453.     //-------------------------------------------------------------
  454.     LPC_TMR32B1->PR = 0;//10;//16bits[max=2^16=65536]  48MHZ(sysahbclk)/48=1000KHZ
  455.     //IOuart要支持高的波特率，PR值要设置尽量小，然后不断调试MR0的值即可达要想要的波特率，一开始
  456.     //调试不成功就是因为PR设为了100太大，导致9600接收总是失败
  457.     //-------------------------------------------------------------
  458.     //One timer can gennerate four interrupts for MR0、MR1、MR2、MR3.
  459.     LPC_TMR32B1->MR0 = SET_UART_BAUD;
  460.     //--------------------------------------------------------------
  461.     LPC_TMR32B1->TCR = 2;//reset 
  462.     LPC_TMR32B1->IR =1;//clear interrupt flag
  463.     LPC_TMR32B1->TCR = 1;//load cfg of ct16b1
  464.     //
  465.     LPC_TMR32B1->TCR =2 ;//reset
  466.     LPC_TMR32B1->TCR =0 ;//stop counter
  467.     //
  468.     NVIC_EnableIRQ(TIMER_32_1_IRQn);    
  469.     NVIC_SetPriority(TIMER_32_1_IRQn,1);    
  470. }
  472. //
  473. void TIMER32_0_IRQHandler (void)//For send destination.
  474. {
  476.     static unsigned char  tx_k=0;
  477.     //
  478.     unsigned char tx_s2;
  480.     //
  481.     LPC_GPIO0->DATA &= ~(1 << 3);//L LED
  482.     LPC_TMR32B0->IR =1;//clear interrupt flag
  485.     //TX
  486.         if(l_send_st){
  487.                 if(l_send_cnt)
  488.                 {
  489.                         if(l_send_cnt == 9)//start bit
  490.                         {
  491.                                 if(l_channel==0)
  492.                                 {
  493.                                         MyIOUART_TX_P->DATA &= ~(1 << MyIOUART_TX_P_INDEX);//L
  494.                                 }
  495.                                 else if(l_channel==1)
  496.                                 { }
  497.                                 else if(l_channel==2)
  498.                                 { }
  499.                                 l_send_cnt=8;
  500.                         }
  501.                         else
  502.                         {
  503.                                 switch(l_send_cnt)
  504.                                 {
  505.                                             case 8:
  506.                                                     tx_s2=0x01;
  507.                                                     break;
  508.                                             case 7:
  509.                                                     tx_s2=0x02;
  510.                                                     break;
  511.                                             case 6:
  512.                                                     tx_s2=0x04;
  513.                                                     break;
  514.                                             case 5:
  515.                                                     tx_s2=0x08;
  516.                                                     break;
  517.                                             case 4:
  518.                                                     tx_s2=0x10;
  519.                                                     break;
  520.                                             case 3:
  521.                                                     tx_s2=0x20;
  522.                                                     break;
  523.                                             case 2:
  524.                                                     tx_s2=0x40;
  525.                                                     break;
  526.                                             case 1:
  527.                                                     tx_s2=0x80;tx_k=0;
  528.                                                     break;
  529.                                             default:
  530.                                                     tx_s2=0x0;
  531.                                                     break;
  532.                                 }
  533.                                 //-------------------------------------------------------------
  534.                                 if(l_channel==0)
  535.                                 {//TX
  536.                                         if(!(l_send_byte&tx_s2)) MyIOUART_TX_P->DATA &= ~(1 << MyIOUART_TX_P_INDEX);//L
  537.                                         else MyIOUART_TX_P->DATA |= (1 << MyIOUART_TX_P_INDEX);//H
  538.                                 }
  539.                                 else if(l_channel==1)
  540.                                 { }
  541.                                 else if(l_channel==2)
  542.                                 { }
  543.                                 //
  544.                                 l_send_cnt--;
  545.                         }
  546.                 }
  547.                 else
  548.                 {
  549.                         if(tx_k<=(MyUart_STOPBITS-1)) //1->两位停止位  0->1位停止位
  550.                         {
  551.                                 if(l_channel==0)
  552.                                 {   MyIOUART_TX_P->DATA |= (1 << MyIOUART_TX_P_INDEX);//H
  553.                                 }
  554.                                 else if(l_channel==1)
  555.                                 { }
  556.                                 else if(l_channel==2)
  557.                                 { }
  558.                                 //
  559.                                 tx_k++;
  560.                         }
  561.                         else
  562.                         {
  563.                             tx_k=0;l_send_cnt  = 9;
  564.                             if(l_send_style)//如果是FIFO发送
  565.                             {
  566.                                     l_send_style=0;
  567.                                     //一个字节发送完
  568.                                     l_Txbuffer[6]--;
  569.                                     if(l_Txbuffer[0]<l_Txbuffer[4])  l_Txbuffer[0]++;
  570.                                     else    l_Txbuffer[0]=8;
  571.                                     //判断是否继续发送
  572.                                     if(l_Txbuffer[6])
  573.                                     {//连续发送
  574.                                             //restart timer
  575.                                             l_send_byte = l_Txbuffer[l_Txbuffer[0]];
  576.                                             l_send_cnt  = 9;
  577.                                             l_send_st = 1;
  578.                                             l_send_style = 1;    
  580.                                     }
  581.                                     else
  582.                                     {
  583.                                       l_send_style = 0;    
  584.                     //修改点1:此处导致出现最后一个字节发送两次！需添加：
  585.                                       l_send_st=0; //reset    
  586.                                         //reset timer    
  587.                                         LPC_TMR32B0->TCR =2;//[0-stop counter  1-start  2-reset]
  588.                                         LPC_TMR32B0->IR = 1;          
  590.                                     }
  591.                             }
  592.                             else
  593.                             {
  594.                                 l_send_st=0; //reset    
  595.                                 //reset timer    
  596.                                 LPC_TMR32B0->TCR =2;//[0-stop counter  1-start  2-reset]
  597.                                 LPC_TMR32B0->IR = 1;          
  598.                             }
  599.                         }
  600.                 }
  601.     }
  603.         //--------------------------------
  604.     LPC_GPIO0->DATA |= (1 << 3);//LED
  605. }
  612. //
  613. void TIMER32_1_IRQHandler (void)//For Receive destination.
  614. {
  615.     static unsigned char  rx_k=0;
  616.       static char  stc_recv_check=0;//静态变量
  617.         static char  rx_interrupt_flag=0;
  618.       //
  619.     unsigned char rx_s1;
  620.     //
  621.     LPC_GPIO0->DATA &= ~(1 << 3);//L LED
  622.     LPC_TMR32B1->IR =1;//clear interrupt flag
  623.        ///
  624.         //RX
  625.     if(l_recv_st)
  626.     {
  627.         if(l_recv_cnt)
  628.                 {
  629.                         switch(l_recv_cnt)
  630.                         {
  631.                                         case 8:
  632.                                                         rx_s1=0;l_recv_byte=0;
  633.                                                 break;
  634.                                         case 7:
  635.                                                         rx_s1=1;
  636.                                                 break;
  637.                                         case 6:
  638.                                                         rx_s1=2;
  639.                                                 break;
  640.                                         case 5:
  641.                                                         rx_s1=3;
  642.                                                 break;
  643.                                         case 4:
  644.                                                         rx_s1=4;
  645.                                                 break;
  646.                                         case 3:
  647.                                                         rx_s1=5;
  648.                                                 break;
  649.                                         case 2:
  650.                                                         rx_s1=6;
  651.                                                 break;
  652.                                         case 1:
  653.                                                         rx_s1=7;rx_k=0;stc_recv_check=0;
  654.                                                 break;
  655.                                         default:
  656.                                                         rx_s1=0;
  657.                                          break;
  658.                         }
  659.                         //-------------------------------------------------------------
  660.                         if(l_channel==0)
  661.                         {//Rx
  662.                             if(MyIOUART_RX_P->DATA & (1<<MyIOUART_RX_P_INDEX))  l_recv_byte+=(1<<rx_s1);
  663.                         }
  664.                         else if(l_channel==1)
  665.                         { }
  666.                         else if(l_channel==2)
  667.                         { }
  668.                         //
  669.                         l_recv_cnt--;
  670.              }
  671.              else
  672.              {
  673.                       if(rx_k<=(MyUart_STOPBITS-1)) //1->两位停止位  0->1位停止位
  674.                         {
  675.                                 if(l_channel==0)
  676.                                 {//Rx 
  677.                                         if(MyIOUART_RX_P->DATA & (1<<MyIOUART_RX_P_INDEX))//检测停止位(H)判断
  678.                                         {  
  679.                                             //stc_recv_check = IOUART_RECV_OK;     
  680.                         stc_recv_check += 2;    
  681.                         stc_recv_check += rx_k;                                            
  682.                                         }
  683.                                         else
  684.                                         { 
  685.                                             stc_recv_check +=3;    
  686.                                               //stc_recv_check = IOUART_RECV_WRONG_EN; 
  687.                                         }
  688.                                 }
  689.                                 else if(l_channel==1)
  690.                                 { }
  691.                                 else if(l_channel==2)
  692.                               { }
  693.                                 //
  694.                                 rx_k++;
  695.                         }
  696.                         else
  697.                         {
  698.                               rx_k=0;l_recv_cnt = 8;
  700.                               if(stc_recv_check <= 5)
  701.                                 {
  702.                                   stc_recv_check = IOUART_RECV_OK;    
  704.                                 }
  705.                                 else
  706.                 {
  707.                                  stc_recv_check = IOUART_RECV_WRONG_EN; 
  708.                                 }                                    
  710.                                 switch(stc_recv_check)
  711.                                 {
  712.                                         case IOUART_RECV_OK://成功接收一个字节
  713.                                                     g_rx_cnt++;
  714.                                               if(l_Rxbuffer[6] < l_Rxbuffer[7])//RxLength
  715.                                                     {
  716.                                                             l_Rxbuffer[6]++;
  717.                                                             l_Rxbuffer[l_Rxbuffer[2]]=l_recv_byte;
  718.                                                             if(l_Rxbuffer[2] < l_Rxbuffer[4])
  719.                                                             {
  720.                                                                     l_Rxbuffer[2]++;
  721.                                                             }
  722.                                                             else
  723.                                                             {
  724.                                                                     l_Rxbuffer[2]=8;
  725.                                                             }
  726.                                                             //连续接收时要精确控制停止位
  727.                                                             if(l_channel==0)
  728.                                                             {
  729.                                                                     if(MyIOUART_RX_P->DATA & (1<<MyIOUART_RX_P_INDEX))
  730.                                                                     {
  731.                                                                             l_recv_st=0; 
  732.                                                                           rx_interrupt_flag = 1;//模拟串口的接收中断
  733.                                                                     }
  734.                                                                     else//检测到下一字节的起始位
  735.                                                                     {//连续接收    
  736.                                                                           //连续收暂时不改变接收缓冲区的数据长度.//l_RxDataLen = 0;//注：连续接收时读取RX缓存区必须使其返回为0，否则会影响数据的接收！
  737.                                                                             //l_recv_byte = 0;//必须清零，因为接收的结果是通过叠加的方式获得的
  738.                                                                             l_recv_cnt = 8;
  739.                                                                             l_recv_st = 1;
  740.                                                                     }
  741.                                                             }
  742.                                                             else if(l_channel==1)
  743.                                                             { }
  744.                                                             else if(l_channel==2)
  745.                                                             { }
  747.                                                     }
  748.                                                     else//接收缓存区满
  749.                                                     {
  750.                                                             l_recv_st=0;
  751.                                                     }
  753.                                                     break;
  754.                                         case IOUART_RECV_WRONG_EN:
  755.                                                          //Record wrong case.Just For Debug.
  756.                                                          l_RxWrongRecord[l_RxWrongRecord[0]]=IOUART_RECV_WRONG_EN;
  757.                                                          if(l_RxWrongRecord[0]<l_RxWrongRecord[1])
  758.                                                          {
  759.                                                                  l_RxWrongRecord[0]++;
  760.                                                          }
  761.                                                          //
  762.                                                          l_RxWrongRecord[l_RxWrongRecord[0]]=l_recv_byte;
  763.                                                          if(l_RxWrongRecord[0]<l_RxWrongRecord[1])
  764.                                                          {
  765.                                                                  l_RxWrongRecord[0]++;
  766.                                                          }
  767.                                                          //
  768.                                l_recv_st=0;
  769.                                                  break;
  770.                                         default:
  771.                                                l_recv_st=0;
  772.                                                  break;
  773.                                 }
  774.                                 //
  775.                                 if(l_recv_st==0)
  776.                                 {
  777.                                         //开RX引脚中断
  778.                                         MyIOUART_RX_P->IC |= (1<<MyIOUART_RX_P_INDEX); //clear flag
  779.                                         MyIOUART_RX_P->IE |= (1<<MyIOUART_RX_P_INDEX); //enable interrupt
  780.                                         //update len
  781.                                         l_RxDataLen = l_Rxbuffer[6];
  782.                     //
  783.                                       //reset timer    
  784.                                       LPC_TMR32B1->TCR = 2;//[0-stop counter  1-start  2-reset]
  785.                                       LPC_TMR32B1->IR = 1;
  787.                                 }
  788.                         }
  789.               }
  790.     }
  791.         //--------------------------------
  792.     LPC_GPIO0->DATA |= (1 << 3);//LED
  793.         //    
  794.         #if ENABLE_ECHO
  795.     if(rx_interrupt_flag)
  796.     {
  797.             rx_interrupt_flag = 0;//
  798.             recv_interrupt();//此函數必須立即返回！（用于回显测试）   
  799.     }
  800.       #endif
  801. }
  803. /*
  804. */
  806. /*USE EXAMPLE:
  807. */

V1.6：单定时器方案

1、DrvIOUART.h+DrvIOUART.c+DrvIOUART1.h+DrvIOUART1.c;蓝色文件为库文件，绿色文件为实例化参考

2、资源占用：1个输入中断+1个定时器（针对实时要求不高的场合）

  1.   文件详细见下载，末尾。

使用小技巧：

在![Image 1][]软件中，对.h文件的第一行添加”*//<<< Use Configuration Wizard in Context Menu >>>*”,可使用其自带的配置功能，方便参数灵活设置。

![Image 1][]

![Image 1][]

附录：

1、IOUART模拟串口调试记录

2016/10/20

1、波特率可调节：支持收发波特率1200->57600

[注: 按r字符进行回显测试，9600才能稳定不出错]

![Image 1][]

19200（停止位为1）时：（单按时回显正常，按住不放回显会出错）

![Image 1][]

停止位为2时，情况一样。

结论：ZLG的模拟串口可以支持到57600，但连续接收数据过快时，baud>9600易出错。

2、两路模拟串口实现

两路模拟串口使用注意事项：

1、两个模拟串口分布在不同PORT LINE，即一个用PORT2，一个用PORT3，不能用同一个PORT。

2、各自使用自己的定时器。

3、每一个函数都要能立即退出，不要使其出现卡死现象。将每个函数想象成在一进就出、各不干扰、独立运行的状态执行。

4、发送过程中产生接收，则以接收的优先级为高。

增加发送自动退让，发送过程随时可能被接收中断，这样会导致发送的数据出现错误但接收的数据都是正常的。BUG…………………..

周立功串口写的很好在只使用一个定时器的情况下，做到了无一错发，无一漏收，可连续收发，波特率稳定可调，这才是正真的高手！！！

增加接收数据计数，发送数据计数！

增加当接收过程终止发送时拉高TX引脚操作！

用串口调试助手测线序数据连续发送且能正常回显的最小时间,目前是300ms

测试串：12 34 56 78 90 1A 3E 5B 12 34 56 78 90 1A 3E 5B

![Image 1][]

![Image 1][]

5、对于连续接收情况的处理

根据精确的停止位的后一位电平高低判断是否为连续接收的情况

使用停止位判断，只能选择一位（k=0）或两位停止位（K=1）

没有校验位

要求连续收发10个字节以上，不行的话调节BAUD系数

6、一旦错过了起始位是否会一直出错！

myiouart:

特点

1、支持一个定时器多通道引脚分时复用，通过channel选择。

  1.  配置一个串口支持多个引脚发送，或接收通过channel变量选择哪一对引脚通道。

![Image 1][]

3、测试模拟串口性能方法：

使用回显测试：

在secureCRT中： 按住两个按键不放看是否能正常显示，或同时按住多个看是否有乱码现象。当同时按住两个字符按键不放时，正常程序每次返回两个按下的字符，此时串口工作在连发状态下。

在串口调试助手中：连续发送多个字节看返回值是否正确。

4、Myiouart_Lpc11c14_V1程序DEBUG记录：

V1.0 — 只支持发送，接收波特率一高就有问题，4800接收

V1.1 — 修改了收发（只是单字节收发），跟换了32位定时器1，并将驱动单独列在一个文件中。

V1.2 — 增加了BUFFER功能

V1.3 — 增加了连续收发，但发送会被接收终止，导致发送的数据错误

V1.4 —

V1.5 — 改为双定器模拟串口

V1.6 — 单定时器串口升级至V1.6使用了结构体操作方式

参考：

IO 模拟 UART 实现-ZLG

链接：https://pan.baidu.com/s/1OgQshNoEe5oI0\_g5cQPXHg 密码：0svc

下载：

V1.5

链接：https://pan.baidu.com/s/11pwEpICOpuX6S5OYy6xUtg 密码：f5l9

V1.6

链接：https://pan.baidu.com/s/1UimbCwUY3uINvajBQ5d8HQ 密码：m044

[Image 1]:

发表评论

表情：
评论列表 （有 0 条评论，472人围观）

还没有评论，来说两句吧...

相关阅读

    相关 51单片机串口通信(UART)

    项目描述： 1.串口工作方式为1(8位UART，波特率可变)，无校验位； 2.通信数据格式为：1位起始位 + 8位数据位 + 1位停止位； 3.上电后MCU给上位机

    Dear 丶Dear 丶/ 0 赞/ 492 阅读

    相关 串口（Uart）的基础知识

    一、串口 1.串口定义：串行接口简称串口，也称串行通信接口或串行通讯接口（通常指COM接口），是采用串行通信方式的扩展接口。 2.串口的特点：数据一位一位的传输。

    清疚清疚/ 0 赞/ 433 阅读