标题: 怎么调试模拟串口？（有带起始位设置的串口助手？） [打印本页]
作者: 121212121212123    时间: 2019-12-18 21:40
标题: 怎么调试模拟串口？（有带起始位设置的串口助手？）
本帖最后由 121212121212123 于 2019-12-18 21:44 编辑



stc15 89c52rc微控制器模拟串行调试：发送到串口助手没问题的，但接收就不行了，有大佬搞这个吗？？

#include <reg52.h>
#include“ config.h”

sbit PIN_RXD = P1 ^ 2;
比特PIN_TXD = P1 ^ 3;

位RxdEnd = 0;
位RxdOrTxd = 0;
位TxdEnd = 0;

unsigned char RxdBuf = 0;
unsigned charTxdBuf = 0;

void ConfigUART（unsigned int baud）;
void StartRXD（）;
void StartTXD（unsigned char dat）;

static unsigned char cnt = 0;

void main（）
{
        EA = 1;
        ConfigUART（9600）;

        while（1）
        {
                led1 = 0;
                while（PIN_RXD）;
                led2 = 0;
                StartRXD（）;
                while（！RxdEnd）;
                StartTXD（RxdBuf）;
                while（！TxdEnd）;
        }

}
void ConfigUART（unsigned int baud）
{
        TMOD＆= 0xF0;
        TMOD | = 0x01;
        TH0 = 256-（11059200/12）/波特;
}
void StartRXD（）
{
        TL0 = TH0;
        ET0 = 1;
        TR0 = 1;
        RxdEnd = 0;
        RxdOrTxd = 0;
}
void StartTXD（unsigned char dat）
{
        TxdBuf = dat;
        TL0 = TH0;
        ET0 = 1;
        TR0 = 1;
        PIN_TXD = 0;
        TxdEnd = 0;
        RxdOrTxd = 1;
}
void InterruptTimer0（）中断1
{                 
// uint8 i;
//
//                 
// TH0 = 256-（11059200/12）/ 9600;
// TL0 = TH0;
//
// i ++;
// if（i == 10）{
// i = 0;
// led4 =〜led4;
//}
                led3 = 0;

        if（RxdOrTxd）
        {//发送
                cnt ++;
                if（cnt <= 8）
                {
                                                
                                                                                                
                        PIN_TXD = TxdBuf＆0x01;
                        TxdBuf >> = 1;
                }
                else if（cnt == 9）
                {
                         PIN_TXD = 1;
                }
                else
                {
                        cnt = 0;
                        TR0 = 0;
                        TxdEnd = 1;
                }
        }
        else            
        {
                if（cnt == 0）
                {
                        if（！PIN_RXD）
                        {
                                RxdBuf = 0;
                                cnt ++;
                        }
                        else
                        {
                                TR0 = 0;
                        }
                }
                if（cnt <= 8）
                                {                 
                                                led4 = 0;
                        RxdBuf >> = 1;            
                        if（PIN_RXD）
                        {
                                RxdBuf | = 0x80;
                        }
                        cnt ++;
                }
                其他
                {
                        cnt = 0;
                        TR0 = 0;
                        if（PIN_RXD）
                        {
                                RxdEnd = 1;
                        }
                }
        }
}


作者: wulin    时间: 2019-12-19 11:04
STC有模拟串口的官方范例程序：
  1. /*---------------------------------------------------------------------*/
  2. /* --- STC MCU Limited ------------------------------------------------*/
  3. /* --- STC15Fxx 系列 软件模拟串口举例----------------------------------*/
  4. /* --- Mobile: (86)13922805190 ----------------------------------------*/
  5. /* --- Fax: 86-0513-55012956,55012947,55012969 ------------------------*/
  6. /* --- Tel: 86-0513-55012928,55012929,55012966-------------------------*/
  7. /* --- Web: www.STCMCU.com --------------------------------------------*/
  8. /* --- Web: www.GXWMCU.com --------------------------------------------*/
  9. /* 如果要在程序中使用此代码,请在程序中注明使用了STC的资料及程序        */
  10. /* 如果要在文章中应用此代码,请在文章中注明使用了STC的资料及程序        */
  11. /*---------------------------------------------------------------------*/

  13. //本示例在Keil开发环境下请选择Intel的8058芯片型号进行编译
  14. //若无特别说明,工作频率一般为11.0592MHz


  17. #include "reg51.h"

  19. //-----------------------------------------
  20. //define baudrate const
  21. //BAUD = 65536 - FOSC/3/BAUDRATE/M (1T:M=1; 12T:M=12)
  22. //NOTE: (FOSC/3/BAUDRATE) must be greater then 98, (RECOMMEND GREATER THEN 110)

  24. //#define BAUD  0xF400                  // 1200bps @ 11.0592MHz
  25. //#define BAUD  0xFA00                  // 2400bps @ 11.0592MHz
  26. //#define BAUD  0xFD00                  // 4800bps @ 11.0592MHz
  27. //#define BAUD  0xFE80                  // 9600bps @ 11.0592MHz
  28. //#define BAUD  0xFF40                  //19200bps @ 11.0592MHz
  29. #define BAUD  0xFFA0                    //38400bps @ 11.0592MHz

  31. //#define BAUD  0xEC00                  // 1200bps @ 18.432MHz
  32. //#define BAUD  0xF600                  // 2400bps @ 18.432MHz
  33. //#define BAUD  0xFB00                  // 4800bps @ 18.432MHz
  34. //#define BAUD  0xFD80                  // 9600bps @ 18.432MHz
  35. //#define BAUD  0xFEC0                  //19200bps @ 18.432MHz
  36. //#define BAUD    0xFF60                //38400bps @ 18.432MHz

  38. //#define BAUD  0xE800                  // 1200bps @ 22.1184MHz
  39. //#define BAUD  0xF400                  // 2400bps @ 22.1184MHz
  40. //#define BAUD  0xFA00                  // 4800bps @ 22.1184MHz
  41. //#define BAUD  0xFD00                  // 9600bps @ 22.1184MHz
  42. //#define BAUD  0xFE80                  //19200bps @ 22.1184MHz
  43. //#define BAUD  0xFF40                  //38400bps @ 22.1184MHz
  44. //#define BAUD  0xFF80                  //57600bps @ 22.1184MHz

  46. sfr AUXR = 0x8E;
  47. sbit RXB = P3^0;                        //define UART TX/RX port
  48. sbit TXB = P3^1;

  50. typedef bit BOOL;
  51. typedef unsigned char BYTE;
  52. typedef unsigned int WORD;

  54. BYTE TBUF,RBUF;
  55. BYTE TDAT,RDAT;
  56. BYTE TCNT,RCNT;
  57. BYTE TBIT,RBIT;
  58. BOOL TING,RING;
  59. BOOL TEND,REND;

  61. void UART_INIT();

  63. BYTE t, r;
  64. BYTE buf[16];

  66. void main()
  67. {
  68.     TMOD = 0x00;                        //timer0 in 16-bit auto reload mode
  69.     AUXR = 0x80;                        //timer0 working at 1T mode
  70.     TL0 = BAUD;
  71.     TH0 = BAUD>>8;                      //initial timer0 and set reload value
  72.     TR0 = 1;                            //tiemr0 start running
  73.     ET0 = 1;                            //enable timer0 interrupt
  74.     PT0 = 1;                            //improve timer0 interrupt priority
  75.     EA = 1;                             //open global interrupt switch

  77.     UART_INIT();

  79.     while (1)
  80.     {                                   //user's function
  81.         if (REND)
  82.         {
  83.             REND = 0;
  84.             buf[r++ & 0x0f] = RBUF;
  85.         }
  86.         if (TEND)
  87.         {
  88.             if (t != r)
  89.             {
  90.                 TEND = 0;
  91.                 TBUF = buf[t++ & 0x0f];
  92.                 TING = 1;
  93.             }
  94.         }
  95.     }
  96. }

  98. //-----------------------------------------
  99. //Timer interrupt routine for UART

  101. void tm0() interrupt 1
  102. {
  103.     if (RING)
  104.     {
  105.         if (--RCNT == 0)
  106.         {
  107.             RCNT = 3;                   //reset send baudrate counter
  108.             if (--RBIT == 0)
  109.             {
  110.                 RBUF = RDAT;            //save the data to RBUF
  111.                 RING = 0;               //stop receive
  112.                 REND = 1;               //set receive completed flag
  113.             }
  114.             else
  115.             {
  116.                 RDAT >>= 1;
  117.                 if (RXB) RDAT |= 0x80;  //shift RX data to RX buffer
  118.             }
  119.         }
  120.     }
  121.     else if (!RXB)
  122.     {
  123.         RING = 1;                       //set start receive flag
  124.         RCNT = 4;                       //initial receive baudrate counter
  125.         RBIT = 9;                       //initial receive bit number (8 data bits + 1 stop bit)
  126.     }

  128.     if (--TCNT == 0)
  129.     {
  130.         TCNT = 3;                       //reset send baudrate counter
  131.         if (TING)                       //judge whether sending
  132.         {
  133.             if (TBIT == 0)
  134.             {
  135.                 TXB = 0;                //send start bit
  136.                 TDAT = TBUF;            //load data from TBUF to TDAT
  137.                 TBIT = 9;               //initial send bit number (8 data bits + 1 stop bit)
  138.             }
  139.             else
  140.             {
  141.                 TDAT >>= 1;             //shift data to CY
  142.                 if (--TBIT == 0)
  143.                 {
  144.                     TXB = 1;
  145.                     TING = 0;           //stop send
  146.                     TEND = 1;           //set send completed flag
  147.                 }
  148.                 else
  149.                 {
  150.                     TXB = CY;           //write CY to TX port
  151.                 }
  152.             }
  153.         }
  154.     }
  155. }

  157. //-----------------------------------------
  158. //initial UART module variable

  160. void UART_INIT()
  161. {
  162.     TING = 0;
  163.     RING = 0;
  164.     TEND = 1;
  165.     REND = 0;
  166.     TCNT = 0;
  167.     RCNT = 0;
  168. }

复制代码
作者: 121212121212123    时间: 2019-12-19 22:45
wulin 发表于 2019-12-19 11:04
STC有模拟串口的官方范例程序：

谢谢了哈，马上去试下
作者: 121212121212123    时间: 2019-12-19 23:27
wulin 发表于 2019-12-19 11:04
STC有模拟串口的官方范例程序：

它的芯片好像不是89C52RC的，是intel 8058的，变量太多了
作者: wulin    时间: 2019-12-20 06:41
121212121212123 发表于 2019-12-19 23:27
它的芯片好像不是89C52RC的，是intel 8058的，变量太多了

不是intel 8058，只是在Keil开发环境下选择Intel的8058芯片型号进行编译。其差别是增加1个寄存器地址
sfr AUXR = 0x8E;  STC公司的1T芯片才有此特殊功能寄存器，
实验是STC15Fxx。这个程序51核心的芯片都可以用，89C52RC没有AUXR寄存器，只要比特率不是太高，不影响对定时器的操作。
作者: wulin    时间: 2019-12-20 11:13
121212121212123 发表于 2019-12-19 23:27
它的芯片好像不是89C52RC的，是intel 8058的，变量太多了

给你改成适合STC89C52RC的模拟串口程序，最高波特率1200，最大数据串16给字节。
  1. #include "reg51.h"

  3. typedef unsigned char uchar;
  4. typedef unsigned int uint;

  6. sbit RXB = P3^0;         //定义UART TX/RX端口
  7. sbit TXB = P3^1;

  9. uchar TBUF,RBUF;
  10. uchar TDAT,RDAT;
  11. uchar TCNT,RCNT;
  12. uchar TBIT,RBIT;
  13. bit TING,RING;
  14. bit TEND,REND;
  15. uchar t, r;
  16. uchar buf[16];

  18. //初始UART模块
  19. void UART_INIT()
  20. {
  21.         TING = 0;
  22.         RING = 0;
  23.         TEND = 1;
  24.         REND = 0;
  25.         TCNT = 0;
  26.         RCNT = 0;
  27.         TMOD = 0x02;   //8位自动重载12T模式
  28.         TL1 = 0xE8;                //设定定时初值(波特率1200)
  29.         TH1 = 0xE8;                //设定定时器重装值
  30. //        TMOD = 0x00;   // 16位自动重载模式中的Time0
  31. //        AUXR = 0x80;   // 1T工作模式
  32. //        TL0 = BAUD;
  33. //        TH0 = BAUD>>8; // 初始Time0和设置重载值
  34.         TR0  = 1;      // tiemr0开始运行
  35.         ET0  = 1;      // 启用Time0中断
  36.         PT0  = 1;      // 提高定时中断优先级
  37.         EA   = 1;      // 打开全局中断开关
  38. }
  39. //
  40. void main()
  41. {
  42.         UART_INIT();   //初始UART模块
  43.         while (1)
  44.         {              //用户功能
  45.                 if (REND)   //接收完成标志为真
  46.                 {
  47.                         REND = 0;//接收完成标志清0
  48.                         buf[r++ & 0x0f] = RBUF;//保存在缓存中
  49.                 }
  50.                 if (TEND)
  51.                 {
  52.                         if (t != r)
  53.                         {
  54.                                 TEND = 0;
  55.                                 TBUF = buf[t++ & 0x0f];//发送缓存中数据
  56.                                 TING = 1;
  57.                         }
  58.                 }
  59.         }
  60. }
  61. //UART定时器中断例程
  62. void tm0() interrupt 1 using 1
  63. {
  64.         if (RING)
  65.         {
  66.                 if (--RCNT == 0)
  67.                 {
  68.                         RCNT = 3;                   //重置发送波特率计数器
  69.                         if (--RBIT == 0)
  70.                         {
  71.                                 RBUF = RDAT;            //将数据保存到RBUF
  72.                                 RING = 0;               //停止接收
  73.                                 REND = 1;               //设置接收完成标志
  74.                         }
  75.                         else
  76.                         {
  77.                                 RDAT >>= 1;
  78.                                 if (RXB) RDAT |= 0x80;  //将RX数据转换为RX缓冲区
  79.                         }
  80.                 }
  81.         }
  82.         else if (!RXB)
  83.         {
  84.                 RING = 1;                       //设置开始接收标志
  85.                 RCNT = 4;                       //初始接收波特率计数器
  86.                 RBIT = 9;                       //initial receive bit number (8 data bits + 1 stop bit)
  87.         }                                                                                          //初始接收比特数（8个数据位+ 1个停止位）
  88.         if (--TCNT == 0)
  89.         {
  90.                 TCNT = 3;                       //重置发送波特率计数器
  91.                 if (TING)                       //判断是否发送
  92.                 {
  93.                         if (TBIT == 0)
  94.                         {
  95.                                 TXB = 0;                //发送起始位
  96.                                 TDAT = TBUF;            //加载数据 TBUF 到 TDAT
  97.                                 TBIT = 9;               //initial send bit number (8 data bits + 1 stop bit)
  98.                         }                                                                        //初始发送比特数（8个数据位+ 1个停止位）
  99.                         else
  100.                         {
  101.                                 TDAT >>= 1;             //将数据转换到CY
  102.                                 if (--TBIT == 0)
  103.                                 {
  104.                                         TXB = 1;
  105.                                         TING = 0;           //停止发送
  106.                                         TEND = 1;           //设置发送完成标志
  107.                                 }
  108.                                 else
  109.                                 {
  110.                                         TXB = CY;           //将CY写入TX端口
  111.                                 }
  112.                         }
  113.                 }
  114.         }
  115. }
复制代码
作者: 121212121212123    时间: 2019-12-20 14:56
wulin 发表于 2019-12-20 11:13
给你改成适合STC89C52RC的模拟串口程序，最高波特率1200，最大数据串16给字节。

我拷过去了，但它会乱码，而且有时发一次，返回几十个数据
作者: wulin    时间: 2019-12-20 17:12
121212121212123 发表于 2019-12-20 14:56
我拷过去了，但它会乱码，而且有时发一次，返回几十个数据

这个程序是在STC89C52RC实验板验证过的，波特率1200。
作者: wulin    时间: 2019-12-20 17:14
121212121212123 发表于 2019-12-20 14:56
我拷过去了，但它会乱码，而且有时发一次，返回几十个数据

晶振11.0592MHz
作者: 121212121212123    时间: 2019-12-21 20:51
wulin 发表于 2019-12-20 17:14
晶振11.0592MHz

先谢谢大佬，我用之前找到的代码跑成功了，现在在想两字节的串口通信，用的是这个代码：

#include<reg52.h>
sbit PIN_RXD = P3^0;
sbit PIN_TXD = P3^1;
bit RxdEnd = 0;
bit RxdOrTxd = 0;
bit TxdEnd = 0;
unsigned char RxdBuf = 0;
unsigned char TxdBuf = 0;
void ConfigUART(unsigned int baud);
void StartRXD();
void StartTXD(unsigned char dat);
void main()
{
        EA = 1;
        ConfigUART(9600);
      
        while(1)
        {
                while(PIN_RXD);
                StartRXD();
                while(!RxdEnd);
                StartTXD(RxdBuf);
                while(!TxdEnd);
        }
      
}
void ConfigUART(unsigned int baud)
{
        TMOD &= 0xF0;
        TMOD |= 0x02;
        TH0 = 256 - (11059200/12)/baud;
}
void StartRXD()
{
        TL0 = 256 - ((256 - TH0)>>1)+4;//之所以加4是因为实地测试发送数据还行，但接收数据误差率太大，估计是51速度太慢，中断中语句太多，当波特率低于9600时可不加4，波特率等于9600则加3以上
        ET0 = 1;
        TR0 = 1;
        RxdEnd = 0;
        RxdOrTxd = 0;
}
void  StartTXD(unsigned char dat)
{
        TxdBuf = dat;
        TL0 = TH0;
        ET0 = 1;
        TR0 = 1;
        PIN_TXD = 0;
        TxdEnd = 0;
        RxdOrTxd = 1;
}
void InterruptTimer0() interrupt 1
{
        static unsigned char cnt = 0;
        if(RxdOrTxd)
        {
                cnt++;
                if(cnt <= 8)
                {
                        PIN_TXD = TxdBuf & 0x01;
                        TxdBuf >>= 1;
                }
                else if(cnt == 9)
                {
                         PIN_TXD = 1;
                }
                else
                {
                        cnt = 0;
                        TR0 = 0;
                        TxdEnd = 1;
                }
        }
        else
        {
                if(cnt == 0)
                {
                        if(!PIN_RXD)
                        {
                                RxdBuf = 0;
                                cnt++;
                        }
                        else
                        {
                                TR0 = 0;
                        }
                }
                else if(cnt <= 8)
                {
                        RxdBuf >>= 1;            
                        if(PIN_RXD)
                        {
                                RxdBuf |= 0x80;
                        }
                        cnt++;
                }
                else
                {
                        cnt = 0;
                        TR0 = 0;
                        if(PIN_RXD)
                        {
                                RxdEnd = 1;
                        }
                }
        }
}
作者: 121212121212123    时间: 2019-12-21 20:51
wulin 发表于 2019-12-20 17:14
晶振11.0592MHz

如果要实现两个字节的模拟串口通信，会不会难度很大？？
作者: 121212121212123    时间: 2019-12-21 21:22
wulin 发表于 2019-12-20 17:14
晶振11.0592MHz

谢谢大佬，都搞定了
作者: 121212121212123    时间: 2019-12-21 21:24
STC89C52RC 双字节两次传输串口通信模拟（可扩展多字节）：
#include<reg52.h>
#include "config.h"
#include "lcd1602.h"

sbit PIN_RXD = P3^0;
sbit PIN_TXD = P3^1;

bit RxdEnd = 0;
bit RxdOrTxd = 0;
bit TxdEnd = 0;

unsigned int RxdBuf = 0;
unsigned int TxdBuf = 0;

void ConfigUART(unsigned int baud);
void StartRXD();
void StartTXD(unsigned char dat);

unsigned char *p;
//unsigned char *p2;
unsigned char buff[3];
//unsigned char buff2[2];
unsigned char key;
unsigned char i = 0;

void main()
{
        EA = 1;
        ConfigUART(9600);
      
        while(1)
        {
                                led1 = ~led1;
                                while(PIN_RXD);        //0低电平进入
                while(key <= 1){        //key = 0,下一次key = 1;
                                        while(PIN_RXD);
                        StartRXD();
                        while(!RxdEnd);
                                        key++;                        //高电平时间
                                }
                                led3 = ~led3;
                                key = 0;
                                for(i = 0;i<=1;i++){
                                        StartTXD(buff[i]);
                                        while(!TxdEnd);
                                }                              
                                p = buff;
                                Lcd1602_Init();
                                Lcd1602_Show_String(1,1,p);
                       

        }
      
}
void ConfigUART(unsigned int baud)
{
        TMOD &= 0xF0;
        TMOD |= 0x02;
        TH0 = 256 - (11059200/12)/baud;
}
void StartRXD()
{
        TL0 = 256 - ((256 - TH0)>>1)+20;//之所以加4是因为实地测试发送数据还行，但接收数据误差率太大，估计是51速度太慢，中断中语句太多，当波特率低于9600时可不加4，波特率等于9600则加3以上
        ET0 = 1;
        TR0 = 1;
        RxdEnd = 0;
        RxdOrTxd = 0;
}
void  StartTXD(unsigned char dat)
{
        TxdBuf = dat;
        TL0 = TH0;
        ET0 = 1;
        TR0 = 1;
        PIN_TXD = 0;
        TxdEnd = 0;
        RxdOrTxd = 1;
}
void InterruptTimer0() interrupt 1
{
        static unsigned char cnt = 0;
        if(RxdOrTxd)
        {
                cnt++;
                if(cnt <= 8)
                {
                        PIN_TXD = TxdBuf & 0x01;
                        TxdBuf >>= 1;
                }
                else if(cnt == 9)
                {
                         PIN_TXD = 1;
                }
                else
                {
                               led4 = ~led4;
                                            cnt = 0;
                        TR0 = 0;
                        TxdEnd = 1;
                }
        }
        else
        {
                if(cnt == 0)
                {
                        if(!PIN_RXD)
                        {
                                RxdBuf = 0;
                                cnt++;
                        }
                        else
                        {
                                TR0 = 0;
                        }
                }
                else if(cnt <= 8)
                {
                        RxdBuf >>= 1;            
                        if(PIN_RXD)
                        {
                                RxdBuf |= 0x80;
                        }
                        cnt++;
                }
                else
                {
                                                if(key == 0){
                                                    buff[0] = RxdBuf;
                                                }else if(key == 1){
                                                        buff[1] = RxdBuf;
                                                        buff[2] = '\0';       
                                                }
                                               
//                                                buff[1] = '\0';
                        cnt = 0;
                        TR0 = 0;
                        if(PIN_RXD)         //当两个字节发送时，存不存在不为高电平？
                        {
                                led2 = ~led2;
                                                                RxdEnd = 1;
                        }
                }
        }
}
作者: hepen2002    时间: 2023-5-11 20:53
楼主。太厉害了，我也在看。你那个看懂了？    发送时,PIN_TXD = TxdBuf & 0x01;为什么先要&这个一步，还有接收时
RXDBuf |=0x80;为什么要走这一步呢



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