找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3618|回复: 2
打印 上一主题 下一主题
收起左侧

STC15F104W单片机虚拟串口 字符串比较源程序

[复制链接]
跳转到指定楼层
楼主
ID:481908 发表于 2019-2-28 11:33 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
STC15F104W虚拟串口 字符串比较

单片机源程序如下:
  1. //本示例在Keil开发环境下请选择Intel的8058芯片型号进行编译
  2. //若无特别说明,工作频率一般为11.0592MHz


  3. #include "reg51.h"

  4.   #include<string.h>

  5.    #define d         5        //数组位定义
  6. //-----------------------------------------
  7. //define baudrate const
  8. //BAUD = 65536 - FOSC/3/BAUDRATE/M (1T:M=1; 12T:M=12)
  9. //NOTE: (FOSC/3/BAUDRATE) must be greater then 98, (RECOMMEND GREATER THEN 110)

  10. //#define BAUD  0xF400                  // 1200bps @ 11.0592MHz
  11. //#define BAUD  0xFA00                  // 2400bps @ 11.0592MHz
  12. //#define BAUD  0xFD00                  // 4800bps @ 11.0592MHz
  13. #define BAUD  0xFE80                  // 9600bps @ 11.0592MHz
  14. //#define BAUD  0xFF40                  //19200bps @ 11.0592MHz
  15. //#define BAUD  0xFFA0                    //38400bps @ 11.0592MHz

  16. //#define BAUD  0xEC00                  // 1200bps @ 18.432MHz
  17. //#define BAUD  0xF600                  // 2400bps @ 18.432MHz
  18. //#define BAUD  0xFB00                  // 4800bps @ 18.432MHz
  19. //#define BAUD  0xFD80                  // 9600bps @ 18.432MHz
  20. //#define BAUD  0xFEC0                  //19200bps @ 18.432MHz
  21. //#define BAUD    0xFF60                //38400bps @ 18.432MHz

  22. //#define BAUD  0xE800                  // 1200bps @ 22.1184MHz
  23. //#define BAUD  0xF400                  // 2400bps @ 22.1184MHz
  24. //#define BAUD  0xFA00                  // 4800bps @ 22.1184MHz
  25. //#define BAUD  0xFD00                  // 9600bps @ 22.1184MHz
  26. //#define BAUD  0xFE80                  //19200bps @ 22.1184MHz
  27. //#define BAUD  0xFF40                  //38400bps @ 22.1184MHz
  28. //#define BAUD  0xFF80                  //57600bps @ 22.1184MHz

  29. sfr AUXR = 0x8E;
  30. sbit RXB = P3^0;                        //define UART TX/RX port
  31. sbit TXB = P3^1;

  32. typedef bit BOOL;
  33. typedef unsigned char BYTE;
  34. typedef unsigned int WORD;












  35. BYTE TBUF,RBUF;
  36. BYTE TDAT,RDAT;
  37. BYTE TCNT,RCNT;
  38. BYTE TBIT,RBIT;
  39. BOOL TING,RING;
  40. BOOL TEND,REND;

  41. void UART_INIT();

  42.   unsigned char r;


  43.            bit b;

  44. BYTE t, r;
  45. BYTE buf[16];

  46. void RUSRT();

  47. void TUSRT(unsigned char dat,f);

  48. sbit R1=P3^3; //输出1
  49. sbit R2=P3^4;//输出2

  50.   bit cmd;  //接收完成标志

  51.   bit Tcmd;
  52. static unsigned char rc;        //接收计数
  53. static  unsigned char tc;        //发送计数
  54. static          unsigned char  a1[d]={0x61,0x62,0x63,0x64,0x65}        ;        //5位 比数组多1位 结束位
  55.           


  56. static   unsigned        char q;

  57. unsigned char c;  //数据位计数

  58. unsigned char *p; //数据指针

  59.   unsigned int n;








  60. void main()
  61. {
  62.           unsigned char fc;         //发送延时




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

  77.     UART_INIT();

  78.     while (1)
  79.     {                                   //user's function
  80.       
  81.            RUSRT();          //调用接收函数
  82.           


  83.                 if(cmd==1)           //接收完成

  84.                 {        

  85.                                     if(c!=4)        //数据位错误

  86.                                   {
  87.                                                        //发送错误指示
  88.                                           c=0;
  89.                                         cmd=0;
  90.                                   
  91.                                  
  92.                                   }







  93.                          else  if(c==4)           //数据位正确

  94.                            {

  95.                           
  96.                        

  97.                                             if( 0== strcmp (a1,"R1ONen" )) //字符比较
  98.                                         {       
  99.                                                
  100.                                                 R1=0;
  101.        
  102.                          

  103.                                           fc = sizeof(a1);         //计算数组位数
  104.                                          for (n=0;n<20000;n++);
  105.                                           TING =1;
  106.                                         TEND=1;
  107.                                          TUSRT(a1,fc); //调用发送函数

  108.          }
  109.                                        
  110.                                        
  111.                                        
  112.                                        
  113.                                               if( 0== strcmp (a1,"R1OFen" ))          //字符比较
  114.                                         {       
  115.                                                
  116.                                                 R1=1;
  117.        
  118.                          

  119.                                           fc = sizeof(a1);                                  //计算数组位数
  120.                                          for (n=0;n<20000;n++);
  121.                                           TING =1;
  122.                                         TEND=1;
  123.                                          TUSRT(a1,fc);                                         //调用发送函数

  124.          }
  125.                                        
  126.                                        
  127.                                        
  128.                                        
  129.                                        
  130.                                                if( 0== strcmp (a1,"R2ONen" ))          //字符比较
  131.                                         {       
  132.                                                
  133.                                                 R2=0;
  134.        
  135.                          

  136.                                           fc = sizeof(a1);                                  //计算数组位数
  137.                                          for (n=0;n<20000;n++);
  138.                                           TING =1;
  139.                                         TEND=1;
  140.                                          TUSRT(a1,fc);                                         //调用发送函数

  141.          }
  142.                                        
  143.                                        
  144.                                                if( 0== strcmp (a1,"R2OFen" ))          //字符比较
  145.                                         {       
  146.                                                
  147.                                                 R2=1;
  148.        
  149.                          

  150.                                           fc = sizeof(a1);                                  //计算数组位数
  151.                                          for (n=0;n<20000;n++);
  152.                                           TING =1;
  153.                                         TEND=1;
  154.                                          TUSRT(a1,fc);                                         //调用发送函数

  155.          }
  156.                                        
  157.                                        
  158.                                        
  159.                                        
  160.                                        
  161.                                        
  162.                                
  163.                                
  164.                                
  165.                                
  166.                                
  167.                                
  168.                                
  169.                                
  170.                                
  171.                                
  172.                                
  173.                                
  174.                                
  175.                                
  176.                                
  177.                                                 }
  178.                                                        
  179.                                                        
  180.                                                        
  181.                                                        
  182.                                                        
  183.                                                        
  184.                          }


  185.                
  186.                  }

  187.          }
  188.                                           

  189.                                





  190.    


  191.    void RUSRT()           //接收函数


  192.    {

  193.                


  194.          if (REND)
  195.         {
  196.             REND = 0;

  197.                                  

  198.                                 if (RBUF!='n') //判断不是结束符
  199.                            {          

  200.                             a1[rc]=RBUF;  //接收传送数组位
  201.                                 rc++;
  202.                                 c++;

  203.                                           }


  204.                                 else  if(RBUF=='n')        //判断是结束符

  205.                                 {REND=0;         
  206.                                 rc=0;
  207.                                 cmd=1;
  208.                        


  209.                        
  210.                                 }




  211.                    }


  212.                    }





  213.            void TUSRT(unsigned char dat,f)         //发送函数


  214.          {
  215.            

  216.                
  217.         if (TEND)
  218.         {                  
  219.                           
  220.                            TEND=0;
  221.                
  222.                                   
  223.                                
  224.                                 if(tc<=f)        //发送数据位比较

  225.                            {
  226.                                   
  227.                                          TBUF =a1[tc];          //数组位数据发送到发送寄存器
  228.                                         tc++;
  229.                                   p++;

  230.                                          }


  231.                                          else if (tc>=f)        //发送数据比较

  232.                                          {
  233.                                          
  234.                                                   cmd =0;         //发送复位
  235.                                                  c=0;
  236.                                          
  237.                                          tc=0;


  238.                                                     TEND=0;         //复位
  239.                                                    TING=0;
  240.                                                



  241.                           }

  242.                        
  243.             }
  244.                                          
  245.           }

  246.                                        
  247.                                

  248.                          

  249. //-----------------------------------------
  250. //Timer interrupt routine for UART

  251. void tm0() interrupt 1 using 1
  252. {
  253.     if (RING)
  254.     {
  255.         if (--RCNT == 0)
  256.         {
  257.             RCNT = 3;                   //reset send baudrate counter
  258.             if (--RBIT == 0)
  259.             {
  260.                 RBUF = RDAT;            //save the data to RBUF
  261.                 RING = 0;               //stop receive
  262.                 REND = 1;               //set receive completed flag
  263.             }
  264.             else
  265.             {
  266.                 RDAT >>= 1;
  267.                 if (RXB) RDAT |= 0x80;  //shift RX data to RX buffer
  268.             }
  269.         }
  270.     }
  271.     else if (!RXB)
  272.     {
  273.         RING = 1;                       //set start receive flag
  274.         RCNT = 4;                       //initial receive baudrate counter
  275.         RBIT = 9;                       //initial receive bit number (8 data bits + 1 stop bit)
  276.     }

  277.     if (--TCNT == 0)
  278.     {
  279.         TCNT = 3;                       //reset send baudrate counter
  280.         if (TING)                       //judge whether sending
  281.         {
  282.             if (TBIT == 0)
  283.             {
  284.                 TXB = 0;                //send start bit
  285.                 TDAT = TBUF;            //load data from TBUF to TDAT
  286.                 TBIT = 9;               //initial send bit number (8 data bits + 1 stop bit)
  287.             }
  288.             else
  289.             {
  290.                 TDAT >>= 1;             //shift data to CY
  291.                 if (--TBIT == 0)
  292.                 {
  293.                     TXB = 1;
  294.                   TING = 0;           //stop send
  295.                     TEND = 1;           //set send completed flag
  296.                 }
  297.                 else
  298.                 {
  299.                     TXB = CY;           //write CY to TX port
  300.                 }
  301.             }
  302.         }
  303.     }
  304. }

  305. //-----------------------------------------
  306. //initial UART module variable

  307. void UART_INIT()
  308. {
  309.     TING = 0;
  310.     RING = 0;
  311.     TEND = 0;
  312.     REND = 0;
  313.     TCNT = 0;
  314.     RCNT = 0;
  315. }
复制代码

所有资料51hei提供下载:
15模拟串口.rar (28.69 KB, 下载次数: 48)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:418537 发表于 2019-11-5 18:39 | 只看该作者
谢谢分享!!!
回复

使用道具 举报

板凳
ID:917140 发表于 2021-5-21 19:16 | 只看该作者
经鉴定无法正常运行 并且STC-ISP早就能导入型号和头文件到keil中 为什么还要用别的代替?代替了根本不能使用的。STC15F104W和这些相差太多了 各种定义都不同。用代替的没法玩的。
#define MAIN_Fosc                11059200L        //定义主时钟 110 ~ 9600
#define BaudRate                9600                //模拟串口波特率
#define Timer0_Reload                (65536 - MAIN_Fosc / BaudRate / 3)
void main()
{
        InternalRAM_enable();
////        ExternalRAM_enable();

        Timer0_1T();
        Timer0_AsTimer();
        Timer0_16bitAutoReload();
        Timer0_Load(Timer0_Reload);
        Timer0_InterruptEnable();
        Timer0_Run();
        EA = 1;                                                //open global interrupt switch
UART_INIT();
}
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表