设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机上位机控制下位机显示联合 Proteus仿真程序
返回列表 发新帖
查看: 1826|回复: 1
打印 上一主题 下一主题
收起左侧

单片机上位机控制下位机显示联合 Proteus仿真程序

[复制链接]
跳转到指定楼层
楼主
ID:756334 发表于 2020-10-21 13:43 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
还有很多不足的地方，多多包容
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


目前程序还无法正常运行,求大神帮忙修改：
矩阵键盘 点阵 上位机 数码管 蜂鸣器联合仿真.zip (325.64 KB, 下载次数: 15)


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

使用道具 举报

沙发
ID:756334 发表于 2020-10-21 13:50 | 只看该作者

RE: 上位机控制下位机显示联合仿真。

主机代码如下，下属还有两个从机代码。
//主机
  1. #include<reg51.h>
  2. #include<string.h>

  4. #define _SUCC_   0x0f//数据传送成功
  5. #define _ERR_    0xf0//数据传送失败
  6. unsigned char Table[50]={
  7.                                                  0x01, 0x01, 0xd6, 0x93, 0x91, 0xff,0x01,0x01,
  8.                                                  0x01, 0x40, 0x4c, 0x66, 0x72, 0x5e,0x4c,0x40,
  9.                                                  0xc4, 0xc6, 0xc3, 0xff, 0xff, 0xc0,0xc0,0xc0,
  10.                                                  0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8};//要发送的数据

  12. unsigned char Table0[8]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8};
  13. unsigned char Buff[50];  //数据缓冲区
  14. unsigned char temp=0xff;
  15. sbit KEY1=P1^0;//开关一号
  16. sbit KEY2=P1^1;//开关二号
  17. //unsigned char addr;                                                                                                                                          

  19. //延时1ms函数
  20. void delay_1ms(unsigned int t)
  21. {
  22.         unsigned int x,y;
  23.         for(x=t;x>0;x--)
  24.           for(y=110;y>0;y--);
  25. }
  26. //缓冲区初始化
  27. void Buff_init()
  28. {
  29.         unsigned char i;    //将Table里的数据放到缓冲区里
  30. //        for(i=0;i<20;i++)
  31.          for(i=0;i<50;i++)
  32.         {
  33.           Buff[i]= Table[i];//将Table里的数据放到Buffp[]里
  34.           delay_1ms(100);//延时100ms
  35.         }
  36. }

  38. //缓冲区初始化0
  39. void Buff_init0()
  40. {
  41.         unsigned char i;    //将Table里的数据放到缓冲区里
  42.         for(i=0;i<20;i++)  
  43.         {
  44.           Buff[i]= Table0[i];//将Table里的数据放到Buffp[]里
  45.           delay_1ms(100);//延时100ms
  46.         }
  47. }

  49. //串口初始化函数
  50. void serial_init()
  51. {
  52.         TMOD=0x20; //定时器1工作于方式2(00100000)M1=1,M0=0
  53.         TH1=0xfd;//定时器赋初值  
  54.         TL1=0xfd; //波特率为9600
  55.         PCON=0;//波特率正常
  56.         SCON=0xd0;  //串口工作于方式3  11010000
  57.         TR1=1;  //开启定时器
  58.         TI=0;//开启发送数据
  59.         RI=0;//开启接受数据
  60. }
  61. //发送数据函数
  62. void SEND_data(unsigned char *Buff)//Buff数据缓冲区
  63. {
  64.         unsigned char i;
  65.         unsigned char lenth;
  66.         unsigned char check;
  67.         lenth=strlen(Buff);   //计算数据长度
  68.         check=lenth;
  69.         
  70.         TI=0;       //开启发送
  71.         TB8=0;      //发送数据帧
  72.         SBUF=lenth;//发送数据长度   sbuf：串行口数据缓冲寄存器
  73.         while(!TI);//此时ti==0
  74.         TI=0;//开启发送
  75.                  
  76.         for(i=0;i<lenth;i++)  //发送数据
  77.         {
  78.           check=check^Buff[i];//按位异或，同为一不同为零，
  79.           TB8=0;
  80.           SBUF=Buff[i]; //将Buff[i]中的数据存入单片机数据缓存区  
  81.           while(!TI);
  82.           TI=0;//开启发送
  83.         }
  84.         //发送校验字节
  85.         TB8=0;      
  86.         SBUF=check;   
  87.         while(!TI);
  88.         TI=0;     
  89. }
  90. //向指定从机地址发送数据
  91. void ADDR_data(unsigned addr)
  92. {
  93.         while(temp!=addr) //主机等待从机返回其地址作为应答信号
  94.         {
  95.           TI=0;    //发送从机地址
  96.           TB8=1;    //发送地址帧
  97.           SBUF=addr;
  98.           while(!TI);
  99.           TI=0;
  100.          
  101.           RI=0;//开始接受数据
  102.           while(!RI);
  103.           temp=SBUF;
  104.           RI=0;
  105.         }
  106.         
  107.         temp=_ERR_;   //主机等待从机数据接收成功信号
  108.         while(temp!=_SUCC_)//当发送成功时
  109.         {
  110.           SEND_data(Buff);
  111.           RI=0;
  112.           while(!RI);
  113.           temp=SBUF;
  114.           RI=0;
  115.         }
  116. }


  119. void chushihua()
  120. {
  121.         Buff_init();//先进行缓冲区初始化
  122.         serial_init();//串口初始化
  123.         while(1)
  124.         {
  125.           if(KEY1==0)//开关一按下
  126.           {
  127.                    delay_1ms(5);//延时5ms确认是否误判
  128.                    if(KEY1==0)        //如果没有误判
  129.                    {
  130.                     while(!KEY1);
  131.                     ADDR_data(0x01);//发送从机地址
  132.                    }
  133.           }
  134.         }
  135. }



  139. void chushihua0()
  140. {
  141.         Buff_init0();//先进行缓冲区初始化
  142.         serial_init();//串口初始化
  143.         while(1)
  144.         {
  145.           if(KEY1==0)//开关一按下
  146.           {
  147.                    delay_1ms(5);//延时5ms确认是否误判
  148.                    if(KEY1==0)        //如果没有误判
  149.                    {
  150.                     while(!KEY1);
  151.                     ADDR_data(0x01);//发送从机地址
  152.                    }
  153.           }
  154.         }
  155. }

  157.       
  158. void main()
  159. {
  160.         Buff_init();//先进行缓冲区初始化
  161.         serial_init();//串口初始化
  162.         while(1)
  163.         {
  164.         ADDR_data(0x01);//发送从机地址
  165.         ADDR_data(0x02);//发送从机地址
  166.         }
  167. }
  168. 从机1号
  169. //从机
  170. #include<reg51.h>
  171. #include<string.h>

  173. #define addr     0x01//从机1的地址
  174. #define _SUCC_   0x0f//数据传送成功
  175. #define _ERR_    0xf0//数据传送失败


  178. sbit k1=P3^2;
  179. sbit k2=P3^3;
  180. sbit k3=P3^4;

  182. sbit D1=P3^5;
  183. sbit D2=P3^6;
  184. sbit D3=P3^7;

  186. unsigned char x;
  187. //延时1ms函数
  188. void delay_1ms(unsigned int t)
  189. {
  190.         unsigned int x,y;
  191.         for(x=t;x>0;x--)
  192.           for(y=110;y>0;y--);
  193. }



  197. unsigned char aa=0xff;//主机与从机之间通信标志
  198. //unsigned char Buff[20];//数据缓冲区
  199. unsigned char Buff[50];//数据缓冲区

  201. //串口初始化函数
  202. void serial_init()
  203. {
  204.         TMOD=0x20; //定时器1工作于方式2          波特率为9600
  205.         TH1=0xfd;  
  206.         TL1=0xfd; //定时器初值
  207.         PCON=0;
  208.         SCON=0xd0;  //串口工作于方式3
  209.         TR1=1;  //开启定时器
  210.         TI=0;
  211.         RI=0;
  212. }
  213. //接收数据函数
  214. unsigned char RECE_data(unsigned char *Buff)
  215. {
  216.         unsigned char i,temp;
  217.         unsigned char lenth;
  218.         unsigned char check;
  219.         
  220.         RI=0;     //开启接收数据（长度）
  221.         while(!RI);
  222.         if(RB8==1)    //若接收到地址帧，则返回0xfe
  223.           return 0xfe;
  224.         lenth=SBUF;
  225.         RI=0; //开启再次接收数据   
  226.         
  227.         check=lenth;
  228.         for(i=0;i<lenth;i++) //接收数据
  229.         {
  230.           while(!RI);
  231.           if(RB8==1)   //若接收到地址帧，则返回0xfe
  232.            return 0xfe;
  233.           Buff[i]=SBUF;   
  234.           check=check^(Buff[i]);//按位异或
  235.           RI=0;
  236.         }

  238.         while(!RI);    //接收校验字节
  239.         if(RB8==1)    //若接收到地址帧，则返回0xfe
  240.           return 0xfe;
  241.         temp=SBUF;
  242.         RI=0;
  243.               
  244.         check=temp^check;  //将从主机接收到的校验码与自己计算的校验码比对（同为零，不同则大于零）
  245.         if(check!=0)   //校验码不一致，表明数据接收错误，向主机发送错误信号，函数返回0xff
  246.         {
  247.           TI=0;
  248.           TB8=0;
  249.           SBUF=_ERR_; //把错误信号赋值到缓冲区待发送
  250.           while(!TI); //发送完毕时跳出循环
  251.           TI=0;
  252.           return 0xff;
  253.         }
  254.         TI=0;           //校验码一致，表明数据接收正确，向主机发送成功信号，函数返回0x00
  255.         TB8=0;
  256.         SBUF=_SUCC_;
  257.         while(!TI);                 //发送成功的信号给主机
  258.         TI=0;
  259.         return 0;
  260. }
  261. const unsigned char CharCode0[8]={0xff,0x81,0x81,0x81,0x81,0x81,0x81,0xff};//P2口代码
  262. unsigned  char  DispBuff[25]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
  263. void chuang1()
  264. {
  265. static char CurPosi;    //定义当前输出位置
  266. D1=0;
  267. P2=Buff[DispBuff[CurPosi]+16]; //输出当前字符显示编码到 P2 口
  268.         switch (CurPosi++)     //当前输出位置加 1   
  269.         {
  270.                 case 0:P1=0x00;break;   //P1.0 置低   
  271.                 case 1:P1=0x20;break; //P1.1 置低   
  272.                 case 2:P1=0x40;break;   //开一点窗   
  273.                 case 3:P1=0x60;break;    //开一半
  274.                 case 4:P1=0x80;break;//开大半
  275.                 case 5:P1=0xa0;break;         //全关
  276.                 case 6:P1=0xc0;break;        //全开
  277.                 case 7:P1=0xe0;break;
  278.         }   
  279.         if(CurPosi>7)  
  280.         CurPosi=0;   //当前输出位置大于 7 则重头开始
  281.         
  282. }
  283. void chuang2()
  284. {
  285. static char CurPosi;    //定义当前输出位置
  286. D2=0;
  287. P2=Buff[DispBuff[CurPosi]+8]; //输出当前字符显示编码到 P2 口
  288.         switch (CurPosi++)     //当前输出位置加 1   
  289.         {
  290.                 case 0:P1=0x00;break;   //P1.0 置低   
  291.                 case 1:P1=0x20;break; //P1.1 置低   
  292.                 case 2:P1=0x40;break;   //开一点窗   
  293.                 case 3:P1=0x60;break;    //开一半
  294.                 case 4:P1=0x80;break;//开大半
  295.                 case 5:P1=0xa0;break;         //全关
  296.                 case 6:P1=0xc0;break;        //全开
  297.                 case 7:P1=0xe0;break;
  298.         }   
  299.         if(CurPosi>7)  
  300.         CurPosi=0;   //当前输出位置大于 7 则重头开始
  301.         
  302. }
  303. void chuang3()
  304. {
  305. static char CurPosi;    //定义当前输出位
  306. D3=0;
  307. P2=Buff[DispBuff[CurPosi]]; //输出当前字符显示编码到 P2 口
  308.         switch (CurPosi++)     //当前输出位置加 1   
  309.         {
  310.                 case 0:P1=0x00;break;   //P1.0 置低   
  311.                 case 1:P1=0x20;break; //P1.1 置低   
  312.                 case 2:P1=0x40;break;   //开一点窗   
  313.                 case 3:P1=0x60;break;    //开一半
  314.                 case 4:P1=0x80;break;//开大半
  315.                 case 5:P1=0xa0;break;         //全关
  316.                 case 6:P1=0xc0;break;        //全开
  317.                 case 7:P1=0xe0;break;
  318.         }   
  319.         if(CurPosi>7)  
  320.         CurPosi=0;   //当前输出位置大于 7 则重头开始

  322. }
  323. //中断函数
  324. void  T0_INTProc(void)  interrupt  1   //T0 定时中断函数
  325. {
  326.         P1=0xff;       //关闭所有显示，消隐
  327.          
  328.         TH0=0xec;     
  329.         TL0=0x78;        //重装计数值   
  330.         TR0=1;     //重启计数，为显示下一字符作准备  
  331. if(k1==0)  
  332. chuang1();
  333. else
  334. D1=1;               
  335. if(k2==0)
  336. chuang2();
  337. else
  338. D2=1;
  339. if(k3==0)  
  340. chuang3();
  341. else
  342. D3=1;
  343. }
  344. void main()
  345. {
  346.         serial_init();          //串口初始化
  347.         while(1)
  348.         {
  349.           SM2=1;            //开启接收地址帧
  350.           while(aa!=addr)  //从机等待主机请求自己的地址
  351.           {
  352.                    RI=0;
  353.                    while(!RI);
  354.                    aa=SBUF;
  355.                    RI=0;
  356.           }
  357.         
  358.           TI=0;     //一旦被请求，从机返回自己地址作为应答，等待接收数据
  359.           TB8=0;
  360.           SBUF=addr;
  361.           while(!TI);
  362.           TI=0;
  363.         
  364.           SM2=0;                  //接收数据帧
  365.           aa=0xff;                                    //从机接收数据，并将数据保存到数据缓冲区
  366.           while(aa==0xff)
  367.           {
  368.                    aa=RECE_data(Buff);                //接收数据
  369.           }
  370.           if(aa==0xfe)
  371.            continue;
  372.                 TMOD=0x01;      //设定 T0 工作在定时方式 1，16位计数  
  373.                 TH0=0xec;     //装入计数值高字节（中断时间）  
  374.                 TL0=0x78;      //装入计数值低字节  
  375.                 EA=1;    //开总中断  
  376.                 ET0=1;       //开 T0 中断  
  377.                 TR0=1;       //启动 T0 计数  
  378.                 while(1);      //无限循环等待中断发生
  379.                
  380.         }
  381. }
复制代码

从机2号
//从机2
  1. #include<reg51.h>
  2. #include<string.h>

  4. #define addr     0x02//从机1的地址
  5. #define _SUCC_   0x0f//数据传送成功
  6. #define _ERR_    0xf0//数据传送失败
  7. unsigned char a;
  8. unsigned char x;
  9. //延时1ms函数
  10. void delay_1ms(unsigned int t)
  11. {
  12.         unsigned int x,y;
  13.         for(x=t;x>0;x--)
  14.           for(y=110;y>0;y--);
  15. }
  16. unsigned char aa=0xff;//主机与从机之间通信标志
  17. unsigned char Buff[50];//数据缓冲区

  19. //串口初始化函数
  20. void serial_init()
  21. {
  22.         TMOD=0x20; //定时器1工作于方式2          波特率为9600
  23.         TH1=0xfd;  
  24.         TL1=0xfd; //定时器初值
  25.         PCON=0;
  26.         SCON=0xd0;  //串口工作于方式3
  27.         TR1=1;  //开启定时器
  28.         TI=0;
  29.         RI=0;
  30. }
  31. //接收数据函数
  32. unsigned char RECE_data(unsigned char *Buff)
  33. {
  34.         unsigned char i,temp;
  35.         unsigned char lenth;
  36.         unsigned char check;
  37.         
  38.         RI=0;     //开启接收数据（长度）
  39.         while(!RI);
  40.         if(RB8==1)    //若接收到地址帧，则返回0xfe
  41.           return 0xfe;
  42.         lenth=SBUF;
  43.         RI=0; //开启再次接收数据   
  44.         
  45.         check=lenth;
  46.         for(i=0;i<lenth;i++) //接收数据
  47.         {
  48.           while(!RI);
  49.           if(RB8==1)   //若接收到地址帧，则返回0xfe
  50.            return 0xfe;
  51.           Buff[i]=SBUF;   
  52.           check=check^(Buff[i]);//按位异或
  53.           RI=0;
  54.         }

  56.         while(!RI);    //接收校验字节
  57.         if(RB8==1)    //若接收到地址帧，则返回0xfe
  58.           return 0xfe;
  59.         temp=SBUF;
  60.         RI=0;
  61.               
  62.         check=temp^check;  //将从主机接收到的校验码与自己计算的校验码比对（同为零，不同则大于零）
  63.         if(check!=0)   //校验码不一致，表明数据接收错误，向主机发送错误信号，函数返回0xff
  64.         {
  65.           TI=0;
  66.           TB8=0;
  67.           SBUF=_ERR_; //把错误信号赋值到缓冲区待发送
  68.           while(!TI); //发送完毕时跳出循环
  69.           TI=0;
  70.           return 0xff;
  71.         }
  72.         TI=0;           //校验码一致，表明数据接收正确，向主机发送成功信号，函数返回0x00
  73.         TB8=0;
  74.         SBUF=_SUCC_;
  75.         while(!TI);                 //发送成功的信号给主机
  76.         TI=0;
  77.         return 0;
  78. }
  79. #define uchar unsigned char//宏定义无符号字符型
  80. #define uint unsigned int  //宏定义无符号整型

  82. //定义分别表示8255A各口的变量
  83. volatile unsigned char xdata Aport _at_ 0x8000;
  84. volatile unsigned char xdata Bport _at_ 0x8001;
  85. volatile unsigned char xdata Cport _at_ 0x8002;
  86. volatile unsigned char xdata Ctrlport _at_ 0x8003;
  87. const unsigned char CharCode1[10]= {0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,0x82,0xf8, 0x80,0x90};//晶体管真值码
  88. unsigned char code seg7code[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90 };//键盘真值码
  89. unsigned char k;


  92. void delay10ms(void) //延时程序
  93. {
  94.         unsigned char i,j;
  95.         for(i=20;i>0;i--)
  96.         for(j=248;j>0;j--);
  97. }

  99. //行扫描获取键盘函数     
  100. void Getch ( )        //取键值函数
  101. {
  102. unsigned char X,Y,Z;
  103. Bport=0x0f; //先对P3 置数 行扫描
  104. if(Bport!=0x0f) //判断是否有键按下
  105.         {
  106.         delay10ms(); //延时,软件去干扰
  107.         if(Bport!=0x0f) //确认按键按下
  108.                 {
  109.                 X=Bport; //保存行扫描时有键按下时状态
  110.                 Bport=0xf0; //列扫描
  111.                 Y=Bport;    //保存列扫描时有键按下时状态
  112.                 Z=X|Y; //取出键值

  114. //获取键盘值函数
  115. switch ( Z ) //判断键值（那一个键按下）
  116.                         {
  117.                                 case 0x77: k=0; break; //对键值赋值
  118.                                 case 0x7b: k=1; break;
  119.                                 case 0x7d: k=2; break;
  120.                                 case 0x7e: k=3; break;
  121.                                 case 0xb7: k=4; break;
  122.                                 case 0xbb: k=5; break;
  123.                                 /*  case 0xbd: k=6; break;
  124.                                 case 0xbe: k=7;
  125.                                 case 0xd7: k=8; break;
  126.                                 case 0xdb: k=9; break;
  127.                                 case 0xdd: k=10;break;
  128.                                 case 0xde: k=11;break;
  129.                                 case 0xe7: k=12;break;
  130.                                 case 0xeb: k=13;break;
  131.                                 case 0xed: k=14;break;
  132.                                 case 0xee: k=15;break;*/
  133.                         }
  134.                  }
  135.         }
  136. }
  137. void main()
  138. {
  139.         serial_init();          //串口初始化
  140.         while(1)
  141.         {
  142.           SM2=1;            //开启接收地址帧
  143.           while(aa!=addr)  //从机等待主机请求自己的地址
  144.           {
  145.                    RI=0;
  146.                    while(!RI);
  147.                    aa=SBUF;
  148.                    RI=0;
  149.           }
  150.         
  151.           TI=0;     //一旦被请求，从机返回自己地址作为应答，等待接收数据
  152.           TB8=0;
  153.           SBUF=addr;
  154.           while(!TI);
  155.           TI=0;
  156.         
  157.           SM2=0;                  //接收数据帧
  158.           aa=0xff;                                    //从机接收数据，并将数据保存到数据缓冲区
  159.           while(aa==0xff)
  160.           {
  161.                    aa=RECE_data(Buff);                //接收数据
  162.           }
  163.           if(aa==0xfe)
  164.            continue;
  165.         while(1){
  166.         a=1;
  167.         while(a)
  168.         {
  169.                 Bport=0xff;
  170.                 Getch();             //调用取键值函数
  171.                 Aport=Buff[k+24]; //查表LED输出

  173.                                 if(k==5)
  174.                                 P1=0x00;
  175.                                 if(P1==0x02)
  176.                                 {
  177.                                 P1=0X01;
  178.                                 a=0;
  179.                                 }
  180.                   }
  181.         }
  182.                
  183.         }
  184. }
复制代码


回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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