标题: stc8f2k08s2单片机双串口同时通讯，怎么实现 [打印本页]
作者: priam    时间: 2018-6-25 21:42
标题: stc8f2k08s2单片机双串口同时通讯，怎么实现
stc8f2k08s2 说明上写着支持双串口。我在stc-isp上看到的范例单独串口1实现，和串口2实现。 这里需求需要 数据 通过串口1接收 ，在通过串口2发出去。

我想把下面的的共能和在一起，同时支持串口1的收发，串口2的收发。 上面的两段代码 就 AUXR 的值不同。合在一起AUXR冲突。
向大家请教。   双串口功能同时实现，代码怎么写

stc-isp上串口1代码：
----------------------------
  1. #include "reg51.h"
  2. #include "intrins.h"

  4. #define FOSC            11059200UL
  5. #define BRT             (65536 - FOSC / 9600 / 4)

  7. sfr     AUXR        =   0x8e;
  8. sfr     T2H         =   0xd6;
  9. sfr     T2L         =   0xd7;
  10. sfr     S2CON       =   0x9a;
  11. sfr     S2BUF       =   0x9b;
  12. sfr     IE2         =   0xaf;

  14. bit busy;
  15. char wptr;
  16. char rptr;
  17. char buffer[16];

  19. void Uart2Isr() interrupt 8 using 1
  20. {
  21.     if (S2CON & 0x02)
  22.     {
  23.         S2CON &= ~0x02;
  24.         busy = 0;
  25.     }
  26.     if (S2CON & 0x01)
  27.     {
  28.         S2CON &= ~0x01;
  29.         buffer[wptr++] = S2BUF;
  30.         wptr &= 0x0f;
  31.     }
  32. }

  34. void Uart2Init()
  35. {
  36.     S2CON = 0x50;
  37.     T2L = BRT;
  38.     T2H = BRT >> 8;
  39.     AUXR = 0x14;
  40.     wptr = 0x00;
  41.     rptr = 0x00;
  42.     busy = 0;
  43. }

  45. void Uart2Send(char dat)
  46. {
  47.     while (busy);
  48.     busy = 1;
  49.     S2BUF = dat;
  50. }

  52. void Uart2SendStr(char *p)
  53. {
  54.     while (*p)
  55.     {
  56.         Uart2Send(*p++);
  57.     }
  58. }

  60. void main()
  61. {
  62.     Uart2Init();
  63.     IE2 = 0x01;
  64.     EA = 1;
  65.     Uart2SendStr("Uart Test !\r\n");

  67.     while (1)
  68.     {
  69.         if (rptr != wptr)
  70.         {
  71.             Uart2Send(buffer[rptr++]);
  72.             rptr &= 0x0f;
  73.         }
  74.     }
  75. }
  76. --------------------结束-以上代码可以运行--------------------------------


  79. stc-isp上串口2代码：
  80. #include "reg51.h"
  81. #include "intrins.h"

  83. #define FOSC            11059200UL
  84. #define BRT             (65536 - FOSC / 115200 / 4)

  86. sfr     AUXR        =   0x8e;

  88. bit busy;
  89. char wptr;
  90. char rptr;
  91. char buffer[16];

  93. void UartIsr() interrupt 4 using 1
  94. {
  95.     if (TI)
  96.     {
  97.         TI = 0;
  98.         busy = 0;
  99.     }
  100.     if (RI)
  101.     {
  102.         RI = 0;
  103.         buffer[wptr++] = SBUF;
  104.         wptr &= 0x0f;
  105.     }
  106. }

  108. void UartInit()
  109. {
  110.     SCON = 0x50;
  111.     TMOD = 0x00;
  112.     TL1 = BRT;
  113.     TH1 = BRT >> 8;
  114.     TR1 = 1;
  115.     AUXR = 0x40;
  116.     wptr = 0x00;
  117.     rptr = 0x00;
  118.     busy = 0;
  119. }

  121. void UartSend(char dat)
  122. {
  123.     while (busy);
  124.     busy = 1;
  125.     SBUF = dat;
  126. }

  128. void UartSendStr(char *p)
  129. {
  130.     while (*p)
  131.     {
  132.         UartSend(*p++);
  133.     }
  134. }

  136. void main()
  137. {
  138.     UartInit();
  139.     ES = 1;
  140.     EA = 1;
  141.     UartSendStr("Uart Test !\r\n");

  143.     while (1)
  144.     {
  145.         if (rptr != wptr)
  146.         {
  147.             UartSend(buffer[rptr++]);
  148.             rptr &= 0x0f;
  149.         }
  150.     }
  151. }
复制代码

----------------------结束-以上代码可以运行---------------------

作者: priam    时间: 2018-6-26 13:09
没有问题了，问题解决了
作者: 1103278135    时间: 2018-8-13 01:53
请问怎么解决的呀？我正好也遇到  谢谢
作者: alanj    时间: 2018-8-15 14:51
怎么解决的?程序还能发上来分享一下?
作者: alanj    时间: 2018-8-15 14:54
请问怎么解决的?遇到这个问题!
作者: angmall    时间: 2018-8-15 18:52
给你改了一下试试。

  1. #include "reg51.h"
  2. #include "intrins.h"

  4. #define FOSC            11059200UL
  5. #define BRT             (65536 - FOSC / 115200 / 4)
  6. #define BRT2            (65536 - FOSC / 9600 / 4)

  8. sfr     AUXR        =   0x8e;
  9. sfr     T2H         =   0xd6;
  10. sfr     T2L         =   0xd7;
  11. sfr     S2CON       =   0x9a;
  12. sfr     S2BUF       =   0x9b;
  13. sfr     IE2         =   0xaf;

  15. bit busy;
  16. char wptr;
  17. char rptr;
  18. char buffer[16];
  19. bit busy2;
  20. char wptr2;
  21. char rptr2;
  22. char buffer2[16];

  24. void UartIsr() interrupt 4 using 1
  25. {
  26.     if (TI)
  27.     {
  28.         TI = 0;
  29.         busy = 0;
  30.     }
  31.     if (RI)
  32.     {
  33.         RI = 0;
  34.         buffer2[wptr2++] = SBUF;
  35.         wptr2 &= 0x0f;
  36.     }
  37. }

  39. void Uart2Isr() interrupt 8 using 1
  40. {
  41.     if (S2CON & 0x02)
  42.     {
  43.         S2CON &= ~0x02;
  44.         busy2 = 0;
  45.     }
  46.     if (S2CON & 0x01)
  47.     {
  48.         S2CON &= ~0x01;
  49.         buffer[wptr++] = S2BUF;
  50.         wptr &= 0x0f;
  51.     }
  52. }

  54. void UartInit()
  55. {
  56.     SCON = 0x50;
  57.     TMOD = 0x00;
  58.     TL1 = BRT;
  59.     TH1 = BRT >> 8;
  60.     TR1 = 1;
  61.     AUXR |= 0x40;
  62.     wptr = 0x00;
  63.     rptr = 0x00;
  64.     busy = 0;
  65. }

  67. void Uart2Init()
  68. {
  69.     S2CON = 0x50;
  70.     T2L = BRT2;
  71.     T2H = BRT2 >> 8;
  72.     AUXR |= 0x14;
  73.     wptr2 = 0x00;
  74.     rptr2 = 0x00;
  75.     busy2 = 0;
  76. }

  78. void UartSend(char dat)
  79. {
  80.     while (busy);
  81.     busy = 1;
  82.     SBUF = dat;
  83. }

  85. void Uart2Send(char dat)
  86. {
  87.     while (busy);
  88.     busy2 = 1;
  89.     S2BUF = dat;
  90. }

  92. void UartSendStr(char *p)
  93. {
  94.     while (*p)
  95.     {
  96.         UartSend(*p++);
  97.     }
  98. }

  100. void Uart2SendStr(char *p)
  101. {
  102.     while (*p)
  103.     {
  104.         Uart2Send(*p++);
  105.     }
  106. }

  108. void main()
  109. {
  110.     UartInit();       
  111.     Uart2Init();
  112.     IE2 = 0x01;
  113.     ES = 1;       
  114.     EA = 1;       
  115.     UartSendStr("Uart Test !\r\n");
  116.     Uart2SendStr("Uart2 Test !\r\n");

  118.     while (1)
  119.     {
  120.         if (rptr != wptr)
  121.         {
  122.             UartSend(buffer[rptr++]);
  123.             rptr &= 0x0f;
  124.         }
  125.         if (rptr2 != wptr2)
  126.         {
  127.             Uart2Send(buffer2[rptr2++]);
  128.             rptr2 &= 0x0f;
  129.         }       
  130.     }
  131. }

  133. //--------------------结束-以上代码可以运行--------------------------------

  135. /*
  136. void main()
  137. {
  138.     while (1)
  139.     {
  140.     }
  141. }
  142. */



复制代码
作者: zfeng    时间: 2018-8-16 09:26
这么多人需要，分享一下让更多的人少走弯路啊！
作者: alanj    时间: 2018-8-21 16:26
有没有遇到采用中断方式每隔几秒种发送一组数据出去之后,调试助手收到多个同样的数据,而在串口发送后加1秒的延迟程序,收到的就只有一组数据.
#include "stc15.h"
#include "USART.h"
#include "intrins.H"




unsigned char TxBusy = 0;        //发送忙检测
unsigned char rxBuff[rxLength]={0};  //接收缓冲区,长度50
unsigned char txBuff[txLength]={0};  //发送缓冲区,长度50
unsigned char rxcnt = 0;                          //接收计数

/* void Uart_Init(void)                //115200bps@11.0592MHz
{
        SCON = 0x50;                //8位数据,可变波特率
        AUXR |= 0x01;                //串口1选择定时器2为波特率发生器
        AUXR |= 0x04;                //定时器2时钟为Fosc,即1T
        T2L = 0xE8;                //设定定时初值
        T2H = 0xFF;                //设定定时初值
        AUXR |= 0x10;                //启动定时器2

    ES = 1;     //使能串口中断
    EA = 1;     //开总中断
}*/


void Uart_Init(void)                //9600bps@11.0592MHz
{
        SCON = 0x50;                //8位数据,可变波特率
        AUXR |= 0x01;                //串口1选择定时器2为波特率发生器
        AUXR |= 0x04;                //定时器2时钟为Fosc,即1T
        T2L = 0xE0;                //设定定时初值
        T2H = 0xFE;                //设定定时初值
        AUXR |= 0x10;                //启动定时器2

    ES = 1;     //使能串口中断
    EA = 1;     //开总中断
}


/*
void Uart1_SendByte(unsigned char dat)
{
   //unsigned int OutTime = 10000;
   //TI = 0;
   //while((TxBusy)&&(OutTime--));
   while(TxBusy);
   SBUF = dat;
   TxBusy = 1;
}*/


void Uart1_SendByte(unsigned char dat)
{

   while(TxBusy);//等待数据发送完成,进入中断,将TI、TxBusy清0
   TxBusy = 1;   
   SBUF = dat;
}  


void Uart1_SendByte_N(unsigned char *dat,unsigned char N)
{
    while(N--)
    {
        Uart1_SendByte(*dat) ;
        dat++;
    }
}

void Uart1_IT_Handle(void) interrupt 4 using 1
{
    unsigned char temp;
    if(RI)
    {
        RI = 0;       //清RI
      
        if(rxcnt<rxLength)
        {
           rxBuff[rxcnt++]=  SBUF;
        
        }
        else
        {
              temp =SBUF;   //读BUFF
        }
    }
    if(TI)
    {
       TI = 0 ;      //清TI
       TxBusy = 0 ;    //清BUSY
    }
}

/*void Uart_SendStr(const char* str)
{
    while(*str)
    {
      Uart1_SendByte(*str);
      str++;
    }
} */
作者: 米明    时间: 2019-9-3 21:20
请问是怎么实现的呢？
作者: 111111486    时间: 2019-11-27 14:17
为什么我把例程刷进去发送的是11但是返回却是19
作者: 聪明的喜羊羊    时间: 2019-11-27 14:23
请问怎么解决的，谢谢
作者: 聪明的喜羊羊    时间: 2019-11-27 14:24
这么多人需要，分享一下让更多的人少走弯路啊！



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1