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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机学习教程(初学者入门) › 解决了初学者常遇到的糟心问题,51单片机proteus仿真数码 ...
返回列表 发新帖
查看: 4|回复: 0
收起左侧

解决了初学者常遇到的糟心问题,51单片机proteus仿真数码管点阵的动态显示乱码故障

[复制链接]
ID:1175293 发表于 2026-9-2 21:43 | 显示全部楼层 |阅读模式
对于初学者最糟心的事就是程序编写的很好，却在仿真时出毛病。程序能在开发板上顺利执行，数码管与点阵屏proteus显示仿真却总是出问题。你的本意是想用仿真发现问题，从而减少在现实中出错的机率，结果到仿真那一步让你抓狂了，薅掉半斤头发，最后发现与你的程序与原理图毛事没有，毛病出在proteus软件上，毕竟人编写的软件，还达不到真正模拟实物的水平，只能努力无限接近。
我用了一整天，和这个问题较劲，期间无数次反对AI提出的问题答案与解决方案。也不能说AI一点帮助没有，在某些问题与思路上还是能给些提示的，但更多的时间是在胡说八道，引你入歧途，所以我浪费了这么长时间。
因为我是直接用P0，和P2端口控制的8个数码管，所以我会用逻辑探针去检查P0端口及与P0相连的线，发现P0口在程序proteus仿真过程中，出现了我不需要的数据，即出现了干扰。
这促使我放弃直接用P0与P2端口，我决定用两个74HC595串转并芯片级联来控制8个数码管。我要看看没有了P0的数据干扰，会有效吗？结果是解决了95%的故障。剩下的故障是因为我有些变量设置成pdata模式，而这个模式也容易造成proteus仿真51芯片工作时，出现对芯片P0与P2寄存器的干扰，从而神秘地间接影响你的变量。总结下来都是一回事，P0与P2寄存器易受干扰，从而在proteus仿真中故障，使你的程序能在开发板运行（实物容错能力比虚拟仿真强），但在仿真时出现乱码，乱跳，甚至不显示，重点体现在有很多个LED灯一起工作的情况，比如更多的数码管与8*8点阵。
实话实说，pdata设置造成P0寄存器的干扰，最后还是AI提出的假设，我验证成功了。单独靠我自己，绝对发现不了这种玄幻。

下面是我用51单片机中断计时，在数码管上显示时间的程序，整合了长短按键功能，按键设置时间功能。AI说pdata设置变量，使得51仿真时，调用了P0去寻址，从而神秘使得51误判我某个按键启动，显示小时部分在00与23之间互跳，分钟部分在00与01间互跳。
故初学者在写程序时，还是尽量不要用片外内存，即不用pdata与xdata，除非256个字节片内RAM用完，尤其是在用数码管与点阵显示数字时。硬件设置上弃用芯片寄存器直接控制数码管与点阵，用类似74HC５９５芯片来传输数据，控制点阵与数码管。
程序中注释掉的是我程序修改前的痕迹，我没有删除，有兴趣的人可以对比一下仿真现象与效果。

  1. #include<reg51.h>
  2. #include<intrins.h>
  3. // #define weixuan P2
  4. // #define duanxuan P0
  5. sbit key1=P3^0;
  6. sbit key2=P3^1;
  7. sbit key3=P3^2;
  8. sbit key4=P3^3;
  9. sbit SH_CP=P1^0;
  10. sbit ST_CP=P1^1;
  11. sbit DS1=P1^2;



  15. unsigned char code KeyCodeMap[4] ={0x26,0x25,0x28,0x27};//up left down right
  16. typedef unsigned char u8;
  17. typedef unsigned int u16;
  18. u8 T0RH,T0RL;
  19. u8 secflag=0;
  20. bit sethour=0,setmin=0;
  21. u8 keysta[4]={1,1,1,1};
  22. signed char hour=0;
  23. signed char min=0;
  24. signed char sec=0;
  25. bit hourblink=0;
  26. bit minblink=0;
  27. /*  共阴极管的数字索引
  28. u8 code gsmg_code[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
  29.                                           0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
  30. */
  31. unsigned char code gsmg_code[] = {   //共阳极管的数字索引
  32. 0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  33. 0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  34. };
  35. // u8 smgbuff[8]={0x3f,0x3f,0x40,0x3f,0x3f,0x40,0x3f,0x3f};//s,min,h
  36. u8 smgbuff[8]={0xC0,0xC0,0xBF,0xC0,0xC0,0xBF,0xC0,0xC0};//s,min,h

  38. u8  wselect[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

  40. unsigned long  keydowntime[4]={0,0,0,0};



  44. void tranfer_data(u8 dat1,u8 dat2)   //595串转并芯片的数据传输函数，dat1交给第一级，控制位选，dat2交给第二级，段选
  45. {
  46.         u8 i=0;
  47.         for(i=0;i<8;i++)
  48.         {
  49.                 DS1=dat2>>7;
  50.                 dat2<<=1;
  51.                 SH_CP=0;
  52.                 _nop_ ();

  54.                 SH_CP=1;
  55.                 _nop_();

  57.                
  58.         }
  59.                         
  60.         
  61.         for(i=0;i<8;i++)
  62.         {
  63.                 DS1=dat1>>7;
  64.                 dat1<<=1;
  65.                 SH_CP=0;
  66.                 _nop_ ();

  68.                 SH_CP=1;
  69.                 _nop_();

  71.                
  72.         }
  73.                 ST_CP=0;
  74.                 _nop_();
  75.                 ST_CP=1;
  76.         _nop_ ();

  78. }        



  82. void ledscan()
  83. {
  84.                  static u8 i=0;
  85. //          duanxuan=0x00;                                                                // hide shade
  86. //    duanxuan=0xFF;
  87. //            weixuan=0x00;
  88. //           weixuan  =(0x01<<i);
  89. //                duanxuan=smgbuff[i];
  90.         
  91.         //                tranfer_data(0x00,0xFF);  //hide shade
  92.                         tranfer_data(wselect[i], smgbuff[i]);//transer wx and dx data        
  93.         
  94.         
  95.                
  96.                 i++;
  97.                 if(i>=8)
  98.                 {
  99.                         i=0;
  100.                 }
  101.                 //i=i&0x07;
  102. }

  104. void configtime(u8 ms)
  105. {
  106.         unsigned long tmp;
  107.         tmp=ms*11059200/12/1000;
  108.         tmp=65536-tmp+15;//delay compensationn
  109.         T0RH=(u8)(tmp>>8);
  110.         T0RL=(u8)tmp;
  111.         EA=1;
  112.         TMOD=0X01;
  113.         TH0=T0RH;
  114.         TL0=T0RL;
  115.         ET0=1;
  116.         TR0=1;
  117. }


  120. void keyscan()
  121. {
  122.         static u8 keybuff[4]={0xff,0xff,0xff,0xff};
  123.         
  124.         u8 j=0;
  125.         keybuff[0]=(keybuff[0]<<1) | key1;
  126.         keybuff[1]=(keybuff[1]<<1) | key2;
  127.         keybuff[2]=(keybuff[2]<<1) | key3;
  128.         keybuff[3]=(keybuff[3]<<1) | key4;
  129.         
  130.         
  131.         for(j=0;j<4;j++)
  132.         {
  133.                 if(keybuff[j]==0x00)
  134.                 {
  135.                         keysta[j]=0;
  136.                         keydowntime[j]+=4;
  137.                 }
  138.                 else if(keybuff[j]==0xff)
  139.                 {
  140.                         keysta[j]=1;
  141.                         keydowntime[j]=0;
  142.                 }
  143.         }
  144.         
  145.         
  146.         
  147.         
  148. }

  150. void keyaction(u8 kode)
  151. {
  152.         //0x26,0x25,0x28,0x27
  153.         switch(kode)
  154.         {
  155.                 case 0x26:
  156.                                                         {
  157.                                                                 if(sethour==1)
  158.                                                                 {
  159.                                                                         
  160.                                                                         hour++;
  161.                                                                
  162.                                                                         if(hour>=24)
  163.                                                                         {
  164.                                                                                 hour=0;
  165.                                                                         }
  166.                                                                         smgbuff[1]=gsmg_code[hour%10];
  167.                                                                         smgbuff[0]=gsmg_code[hour/10];
  168.                                                                 }
  169.                                                                 if(setmin==1)
  170.                                                                 {
  171.                                                                         min++;
  172.                                                                         if(min>=60)
  173.                                                                         {
  174.                                                                                 min=0;
  175.                                                                         }
  176.                                                                         smgbuff[4]=gsmg_code[min%10];
  177.                                                                         smgbuff[3]=gsmg_code[min/10];
  178.                                                                 }
  179.                                                                 break;
  180.                                                         }
  181.                 case 0x25:sethour=~sethour;break;
  182.                 case 0x28:
  183.                                                         {
  184.                                                                 if(sethour==1)
  185.                                                                 {
  186.                                                                         hour--;
  187.                                                                         if(hour<0)
  188.                                                                         {
  189.                                                                                 hour=23;
  190.                                                                         }
  191.                                                                         smgbuff[1]=gsmg_code[hour%10];
  192.                                                                         smgbuff[0]=gsmg_code[hour/10];
  193.                                                                 }
  194.                                                                 if(setmin==1)
  195.                                                                 {
  196.                                                                         min--;
  197.                                                                         if(min<0)
  198.                                                                         {
  199.                                                                                 min=59;
  200.                                                                         }
  201.                                                                         smgbuff[4]=gsmg_code[min%10];
  202.                                                                         smgbuff[3]=gsmg_code[min/10];
  203.                                                                 }
  204.                                                                 break;
  205.                                                         }
  206.                 case 0x27:setmin=~setmin;break;
  207.                 default :break;
  208.         }
  209.         
  210.         
  211. }


  214. void keydrive()
  215. {
  216.         static u8 backup[4]={1,1,1,1};
  217.         u8 k=0;
  218.         static unsigned long  timemax[4]={1000,1000,1000,1000};
  219.         for(k=0;k<4;k++)
  220.         {
  221.                 if(backup[k]!=keysta[k])
  222.                 {
  223.                         backup[k]=keysta[k];
  224.                         if(backup[k]!=0)
  225.                         {
  226.                                 keyaction(KeyCodeMap[k]);
  227.                                 
  228.                         }
  229.                 }
  230.                 if(keydowntime[k]>0)
  231.                 {
  232.                         if(keydowntime[k]>=timemax[k])
  233.                                         {
  234.                                                 keyaction(KeyCodeMap[k]);
  235.                                                 timemax[k]+=200;
  236.                                         }
  237.                
  238.                 }
  239.                 else
  240.                 {
  241.                         timemax[k]=1000;
  242.                 }
  243.         }
  244. }

  246. void time()
  247. {
  248.         if(secflag==1)
  249.         {
  250.                 secflag=0;
  251.                
  252.                 sec++;
  253.                 if(sec==60)
  254.                 {
  255.                         sec=0;
  256.                         
  257.                         min++;
  258.                         if(min==60)
  259.                         {
  260.                                 min=0;
  261.                                 
  262.                                 hour++;
  263.                                 if(hour==24)
  264.                                 {
  265.                                         hour=0;
  266.                                 }
  267.                                 smgbuff[1]=gsmg_code[hour%10];
  268.                                 smgbuff[0]=gsmg_code[hour/10];
  269.                                 
  270.                         }
  271.                         smgbuff[4]=gsmg_code[min%10];
  272.                         smgbuff[3]=gsmg_code[min/10];
  273.                 }
  274.                 smgbuff[7]=gsmg_code[sec%10];
  275.                 smgbuff[6]=gsmg_code[sec/10];
  276.         }
  277.                
  278. }



  282. void main()
  283. {
  284.         configtime(5);  //中断函数中内容较多，1ms可能不够用，故设置成5ms
  285.         
  286.         
  287.         while(1)
  288.         {
  289.                 time();
  290.                 keydrive();
  291.         
  292.                
  293.         }
  294.         
  295. }

  297. void interruptmr() interrupt 1
  298. {
  299.         static u16 timer1=0;
  300.         static u16 timer2=0;
  301.         TH0=T0RH;
  302.         TL0=T0RL;
  303.         ledscan();
  304.         keyscan();
  305.         timer1++;
  306.         timer2++;
  307.         if(timer1==200)
  308.         {
  309.                 timer1=0;
  310.                 secflag=1;
  311.         }
  312.         if(timer2==100)
  313.         {
  314.                 timer2=0;
  315.         
  316.                         if(sethour==1 )
  317.                 {
  318.                                 if(hourblink==0)
  319.                         {
  320.                                 smgbuff[1]=0xFF;
  321.                                 smgbuff[0]=0xFF;
  322.                                 
  323.                         }
  324.                         else
  325.                         {
  326.                                 smgbuff[1]=gsmg_code[hour%10];
  327.                                 smgbuff[0]=gsmg_code[hour/10];
  328.                         }
  329.                         hourblink=~hourblink;
  330.                 }
  331.                 else
  332.                 {
  333.                         smgbuff[1]=gsmg_code[hour%10];
  334.                         smgbuff[0]=gsmg_code[hour/10];
  335.                 }

  337.                 if(setmin==1)
  338.                 {
  339.                                 if(minblink==0)
  340.                         {
  341.                                 smgbuff[4]=0xFF;
  342.                                 smgbuff[3]=0xFF;
  343.                                 
  344.                         }
  345.                         else
  346.                         {
  347.                                 smgbuff[4]=gsmg_code[min%10];
  348.                                 smgbuff[3]=gsmg_code[min/10];
  349.                         }
  350.                         minblink=~minblink;
  351.                 }
  352.                 else
  353.                 {
  354.                         smgbuff[4]=gsmg_code[min%10];
  355.                         smgbuff[3]=gsmg_code[min/10];
  356.                 }
  357.         
  358.         }
  359. }
复制代码

proteus9

proteus9

smgclock.zip

26.64 KB, 下载次数: 0, 下载积分: 黑币 -5

原理图与程序

评分

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

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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