proteus

proteus 8进行仿真单片机出现假死现象

2019-07-18 08:55发布

站内问答 / proteus
2957 7 1662
QQ截图20180329200756.png
并且LCD1602元件也出现显示不全的现象。断电重启后能运行一会儿然后假死。只有重新制作仿真图才能多运行一会儿。求助于各位大佬这是怎么回事啊。谢谢
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
7条回答
勇哥-lzu
1楼-- · 2019-07-18 14:47
程序跑飞了吧   贴上代码看一下 最佳答案
jjy1039
2楼-- · 2019-07-18 17:24
程序调试了吗，先调试程序吧，仿真的硬件一般不会有什么问题
li12345l
3楼-- · 2019-07-18 18:18
jjy1039 发表于 2018-3-30 15:14
程序调试了吗，先调试程序吧，仿真的硬件一般不会有什么问题

不知道程序哪里有问题- -
li12345l
4楼-- · 2019-07-18 21:04
 精彩回答 2  元偷偷看……
li12345l
5楼-- · 2019-07-19 00:43
 精彩回答 2  元偷偷看……
li12345l
6楼-- · 2019-07-19 01:58
勇哥-lzu 发表于 2018-3-30 18:10
程序跑飞了吧   贴上代码看一下
  1. 勇哥-lzu 发表于 2018-3-30 18:10
  2. 程序跑飞了吧   贴上代码
  3. 好的
  4. #include <reg52.h>                                  
  5. #include <intrins.h>

  7. #define uchar unsigned char       
  8. #define uint  unsigned int       

  10. sfr ISP_DATA  = 0xe2;                       
  11. sfr ISP_ADDRH = 0xe3;                       
  12. sfr ISP_ADDRL = 0xe4;                       
  13. sfr ISP_CMD   = 0xe5;                       
  14. sfr ISP_TRIG  = 0xe6;                       
  15. sfr ISP_CONTR = 0xe7;                       

  17. sbit LcdRs_P   = P1^2;   
  18. sbit LcdRw_P   = P1^3;   
  19. sbit LcdEn_P   = P1^4;   
  20. sbit Buzzer_P  = P1^5;   
  21. sbit DHT11_P   = P1^6;                
  22. sbit DHT11_1_P   = P1^7;       
  23. sbit KeySet_P  = P3^2;               
  24. sbit KeyDown_P = P3^3;               
  25. sbit KeyUp_P   = P3^4;               
  26. sbit LedTH_P   = P2^0;               
  27. sbit LedTL_P   = P2^1;               
  28. sbit LedHH_P   = P2^2;               
  29. sbit LedHL_P   = P2^3;       
  30. sbit W_P                                = P2^4;               
  31. sbit W_P_1                        = P2^5;       


  34. uchar temp;                                       
  35. uchar humi;                                       
  36. uchar temp_1;                               
  37. uchar humi_1;                               

  39. uchar AlarmTL;                       
  40. uchar AlarmTH;                       
  41. uchar AlarmHL;               
  42. uchar AlarmHH;                       




  47. void ISP_Disable()
  48. {
  49.         ISP_CONTR = 0;
  50.         ISP_ADDRH = 0;
  51.         ISP_ADDRL = 0;
  52. }


  55. unsigned char EEPROM_Read(unsigned int add)
  56. {
  57.         ISP_DATA  = 0x00;
  58.         ISP_CONTR = 0x83;
  59.         ISP_CMD   = 0x01;
  60.         ISP_ADDRH = (unsigned char)(add>>8);
  61.         ISP_ADDRL = (unsigned char)(add&0xff);
  62.         ISP_TRIG  = 0x46;          
  63.         ISP_TRIG  = 0xB9;
  64.         _nop_();
  65.         ISP_Disable();
  66.         return (ISP_DATA);
  67. }


  70. void EEPROM_Write(unsigned int add,unsigned char ch)
  71. {
  72.         ISP_CONTR = 0x83;
  73.         ISP_CMD   = 0x02;
  74.         ISP_ADDRH = (unsigned char)(add>>8);
  75.         ISP_ADDRL = (unsigned char)(add&0xff);
  76.         ISP_DATA  = ch;
  77.         ISP_TRIG  = 0x46;
  78.         ISP_TRIG  = 0xB9;
  79.         _nop_();
  80.         ISP_Disable();
  81. }


  84. void Sector_Erase(unsigned int add)          
  85. {
  86.         ISP_CONTR = 0x83;
  87.         ISP_CMD   = 0x03;
  88.         ISP_ADDRH = (unsigned char)(add>>8);
  89.         ISP_ADDRL = (unsigned char)(add&0xff);
  90.         ISP_TRIG  = 0x46;
  91.         ISP_TRIG  = 0xB9;
  92.         _nop_();
  93.         ISP_Disable();
  94. }


  97. void DelayMs(uint time)
  98. {
  99.         uint i,j;
  100.         for(i=0;i<time;i++)
  101.                 for(j=0;j<112;j++);
  102. }



  106. void LcdWriteCmd(uchar cmd)
  107. {
  108.         LcdRs_P = 0;
  109.         LcdRw_P = 0;
  110.         LcdEn_P = 0;
  111.         P0=cmd;
  112.         DelayMs(2);
  113.         LcdEn_P = 1;   
  114.         DelayMs(2);
  115.         LcdEn_P = 0;       
  116. }



  120. void LcdWriteData(uchar dat)
  121. {
  122.         LcdRs_P = 1;
  123.         LcdRw_P = 0;
  124.         LcdEn_P = 0;
  125.         P0=dat;
  126.         DelayMs(2);
  127.         LcdEn_P = 1;   
  128.         DelayMs(2);
  129.         LcdEn_P = 0;
  130. }


  133. void LcdInit()
  134. {
  135.         LcdWriteCmd(0x38);        
  136.         LcdWriteCmd(0x0C);        
  137.         LcdWriteCmd(0x06);        
  138.         LcdWriteCmd(0x01);        
  139. }



  143. void LcdGotoXY(uchar line,uchar column)
  144. {
  145.        
  146.         if(line==0)        
  147.                 LcdWriteCmd(0x80+column);
  148.        
  149.         if(line==1)        
  150.                 LcdWriteCmd(0x80+0x40+column);
  151. }



  155. void LcdPrintStr(uchar *str)
  156. {
  157.         while(*str!='')                
  158.                 LcdWriteData(*str++);
  159. }



  163. void LcdPrintNum(uchar num)
  164. {
  165.         LcdWriteData(num/10+48);       
  166.         LcdWriteData(num%10+48);
  167. }


  170. void LcdShowInit()
  171. {
  172.         LcdGotoXY(0,0);                                                               
  173.         LcdPrintStr("  DHT11 System  ");
  174.         LcdGotoXY(1,0);                                                          
  175.         LcdPrintStr("T:   C   H:  %RH");
  176.         LcdGotoXY(1,4);                                                               
  177.         LcdWriteData(0xdf);       
  178. }




  183. void Delay10us()
  184. {
  185.         _nop_();       
  186.         _nop_();
  187.         _nop_();
  188.         _nop_();
  189.         _nop_();
  190.         _nop_();
  191.         _nop_();
  192.         _nop_();
  193.         _nop_();
  194.         _nop_();
  195. }



  199. uchar DhtReadByte(void)
  200. {   
  201.         bit bit_i;
  202.         uchar j;
  203.         uchar dat=0;

  205.         for(j=0;j<8;j++)   
  206.         {
  207.                 while(!DHT11_P);       
  208.                 Delay10us();                       
  209.                 Delay10us();
  210.                 Delay10us();
  211.                 if(DHT11_P==1)       
  212.                 {
  213.                         bit_i=1;
  214.                         while(DHT11_P);
  215.                 }
  216.                 else
  217.                 {
  218.                         bit_i=0;
  219.                 }
  220.                 dat<<=1;                                  
  221.                 dat|=bit_i;   
  222.         }
  223.         return(dat);  
  224. }


  227. void ReadDhtData()
  228. {             
  229.         uchar HumiHig;               
  230.         uchar HumiLow;               
  231.         uchar TemHig;               
  232.         uchar TemLow;               
  233.         uchar check;               
  234.        
  235.         DHT11_P=0;                               
  236.         DelayMs(20);               
  237.         DHT11_P=1;                       

  239.         Delay10us();                        
  240.         Delay10us();
  241.         Delay10us();

  243.         while(!DHT11_P);       
  244.         while(DHT11_P);               


  247.         HumiHig = DhtReadByte();        
  248.         HumiLow = DhtReadByte();
  249.         TemHig  = DhtReadByte();
  250.         TemLow  = DhtReadByte();
  251.         check   = DhtReadByte();

  253.         DHT11_P=1;                               

  255.         if(check==HumiHig + HumiLow + TemHig + TemLow)                
  256.         {
  257.                 temp=TemHig;                        
  258.                 humi=HumiHig;                       
  259.         }
  260. }

  262. uchar Dht_1ReadByte(void)
  263. {   
  264.         bit bit_i;
  265.         uchar j;
  266.         uchar dat_1=0;

  268.         for(j=0;j<8;j++)   
  269.         {
  270.                 while(!DHT11_1_P);       
  271.                 Delay10us();                       
  272.                 Delay10us();
  273.                 Delay10us();
  274.                 if(DHT11_1_P==1)               
  275.                 {
  276.                         bit_i=1;
  277.                         while(DHT11_1_P);
  278.                 }
  279.                 else
  280.                 {
  281.                         bit_i=0;
  282.                 }
  283.                 dat_1<<=1;                                  
  284.                 dat_1|=bit_i;   
  285.         }
  286.         return(dat_1);  
  287. }



  291. void ReadDht_1Data()
  292. {             
  293.         uchar HumiHig_1;               
  294.         uchar HumiLow_1;               
  295.         uchar TemHig_1;                       
  296.         uchar TemLow_1;                       
  297.         uchar check_1;                       
  298.        
  299.         DHT11_1_P=0;                               
  300.         DelayMs(20);                       
  301.         DHT11_1_P=1;                               

  303.         Delay10us();         
  304.         Delay10us();
  305.         Delay10us();

  307.         while(!DHT11_1_P);       
  308.         while(DHT11_1_P);       

  310.         HumiHig_1 = Dht_1ReadByte();        
  311.         HumiLow_1 = Dht_1ReadByte();
  312.         TemHig_1  = Dht_1ReadByte();
  313.         TemLow_1  = Dht_1ReadByte();        
  314.         check_1   = Dht_1ReadByte();

  316.         DHT11_1_P=1;                       

  318.         if(check_1==HumiHig_1 + HumiLow_1 + TemHig_1 + TemLow_1)
  319.         {
  320.                 temp_1=TemHig_1;                        
  321.                 humi_1=HumiHig_1;                       
  322.         }
  323. }



  327. void AlarmJudge(void)
  328. {
  329.         uchar i;

  331.         if(temp>AlarmTH)                               
  332.         {
  333.                 if(temp>temp_1)                       
  334.                 {
  335.                         W_P_1        =        0;
  336.                         LedTH_P=1;
  337.                         LedTL_P=1;
  338.                 }
  339.                 else
  340.                 {
  341.                         LedTH_P=0;
  342.                         LedTL_P=1;
  343.                         W_P_1        =        1;
  344.                 }
  345.         }
  346.         else if(temp<AlarmTL)               
  347.         {
  348.                 if(temp<temp_1)                               
  349.                 {
  350.                         W_P_1        =                0;
  351.                         LedTL_P        =        1;
  352.                         LedTH_P        =        1;
  353.                 }
  354.                 else
  355.                 {
  356.                         LedTL_P=        0;
  357.                         LedTH_P=        1;
  358.                         W_P_1        =                1;
  359.                 }
  360.         }
  361.         else                                                                               
  362.         {
  363.                 LedTH_P=        1;
  364.                 LedTL_P=        1;
  365.                 W_P_1=                1;
  366.         }

  368.         if(humi>AlarmHH)                          
  369.         {
  370.                 if(humi>humi_1)
  371.                 {
  372.                         W_P                =                0;
  373.                         LedHH_P=        1;
  374.                         LedHL_P=        1;
  375.                 }
  376.                 else
  377.                 {
  378.                         W_P                =                1;
  379.                         LedHH_P=        0;
  380.                         LedHL_P=        1;
  381.                 }
  382.         }
  383.         else if(humi<AlarmHL)               
  384.         {
  385.                 if(humi<humi_1)
  386.                 {
  387.                         W_P                =                0;
  388.                         LedHL_P=        1;
  389.                         LedHH_P=        1;
  390.                 }
  391.                 else
  392.                 {
  393.                         W_P                =                1;
  394.                         LedHL_P=        0;
  395.                         LedHH_P=        1;
  396.                 }
  397.         }
  398.         else                                                                          
  399.         {
  400.                 LedHH_P=1;
  401.                 LedHL_P=1;
  402.                 W_P        =        1;
  403.         }

  405.         if((LedHH_P==0)||(LedHL_P==0)||(LedTH_P==0)||(LedTL_P==0)||(W_P==0)||(W_P_1==0))        
  406.         {
  407.                 for(i=0;i<3;i++)
  408.                 {
  409.                         Buzzer_P=0;
  410.                         DelayMs(100);
  411.                         Buzzer_P=1;
  412.                         DelayMs(100);
  413.                 }
  414.         }
  415. }



  419. void KeyScanf()
  420. {
  421.         if(KeySet_P==0)               
  422.         {
  423.                

  425.                 LcdWriteCmd(0x01);                               
  426.                 LcdGotoXY(0,0);
  427.                 LcdPrintStr("Temp:   -       ");
  428.                 LcdGotoXY(1,0);
  429.                 LcdPrintStr("Humi:   -       ");
  430.                
  431.                 LcdGotoXY(0,6);                                                
  432.                 LcdPrintNum(AlarmTL);       
  433.                 LcdGotoXY(0,9);                                                
  434.                 LcdPrintNum(AlarmTH);

  436.                 LcdGotoXY(1,6);                                                
  437.                 LcdPrintNum(AlarmHL);       
  438.                 LcdGotoXY(1,9);                                                 
  439.                 LcdPrintNum(AlarmHH);

  441.                 LcdGotoXY(0,7);                                                
  442.                 LcdWriteCmd(0x0F);                       
  443.                
  444.                 DelayMs(10);                                                 
  445.                 while(!KeySet_P);                                        
  446.                 DelayMs(10);                                          


  449.                 while(KeySet_P)                                       
  450.                 {
  451.                         if(KeyDown_P==0)                               
  452.                         {
  453.                                 if(AlarmTL>0)                                       
  454.                                         AlarmTL--;
  455.                                 LcdGotoXY(0,6);                                
  456.                                 LcdPrintNum(AlarmTL);                 
  457.                                 LcdGotoXY(0,7);                               
  458.                                 DelayMs(350);                                       
  459.                         }
  460.                         if(KeyUp_P==0)                                 
  461.                         {
  462.                                 if(AlarmTL<99)                         
  463.                                         AlarmTL++;
  464.                                 LcdGotoXY(0,6);                                 
  465.                                 LcdPrintNum(AlarmTL);
  466.                                 LcdGotoXY(0,7);                               
  467.                                 DelayMs(350);                                       
  468.                         }       
  469.                 }

  471.                 LcdGotoXY(0,10);
  472.                 DelayMs(10);                                                 
  473.                 while(!KeySet_P);                                        
  474.                 DelayMs(10);                                                 


  477.                                
  478.                 while(KeySet_P)                                         
  479.                 {
  480.                         if(KeyDown_P==0)                               
  481.                         {
  482.                                 if(AlarmTH>0)                                 
  483.                                         AlarmTH--;
  484.                                 LcdGotoXY(0,9);                          
  485.                                 LcdPrintNum(AlarmTH);
  486.                                 LcdGotoXY(0,10);                       
  487.                                 DelayMs(350);                                       
  488.                         }
  489.                         if(KeyUp_P==0)                          
  490.                         {
  491.                                 if(AlarmTH<99)                                
  492.                                         AlarmTH++;
  493.                                 LcdGotoXY(0,9);                               
  494.                                 LcdPrintNum(AlarmTH);
  495.                                 LcdGotoXY(0,10);                       
  496.                                 DelayMs(350);                                       
  497.                         }                                                                 
  498.                 }

  500.                 LcdGotoXY(1,7);
  501.                 DelayMs(10);                                                 
  502.                 while(!KeySet_P);                                        
  503.                 DelayMs(10);                                          
  504.                
  505.                

  507.                 while(KeySet_P)                                                
  508.                 {
  509.                         if(KeyDown_P==0)                               
  510.                         {
  511.                                 if(AlarmHL>0)                                        
  512.                                         AlarmHL--;
  513.                                 LcdGotoXY(1,6);                               
  514.                                 LcdPrintNum(AlarmHL);
  515.                                 LcdGotoXY(1,7);                               
  516.                                 DelayMs(350);
  517.                         }
  518.                         if(KeyUp_P==0)                                        
  519.                         {
  520.                                 if(AlarmHL<99)                         
  521.                                         AlarmHL++;
  522.                                 LcdGotoXY(1,6);                          
  523.                                 LcdPrintNum(AlarmHL);
  524.                                 LcdGotoXY(1,7);                         
  525.                                 DelayMs(350);                                       
  526.                         }       
  527.                 }

  529.                 LcdGotoXY(1,10);
  530.                 DelayMs(10);                                                 
  531.                 while(!KeySet_P);                                        
  532.                 DelayMs(10);                                                 
  533.                

  535.                 while(KeySet_P)                                                
  536.                 {
  537.                         if(KeyDown_P==0)                                
  538.                         {
  539.                                 if(AlarmHH>0)                                 
  540.                                         AlarmHH--;
  541.                                 LcdGotoXY(1,9);                          
  542.                                 LcdPrintNum(AlarmHH);
  543.                                 LcdGotoXY(1,10);                       
  544.                                 DelayMs(350);
  545.                         }
  546.                         if(KeyUp_P==0)                                        
  547.                         {
  548.                                 if(AlarmHH<99)                               
  549.                                         AlarmHH++;
  550.                                 LcdGotoXY(1,9);                                
  551.                                 LcdPrintNum(AlarmHH);
  552.                                 LcdGotoXY(1,10);                        
  553.                                 DelayMs(350);                                       
  554.                         }       
  555.                 }

  557.                 LcdWriteCmd(0x0C);                         
  558.                 LcdShowInit();                                               

  560.                 DelayMs(10);                                         
  561.                 while(!KeySet_P);                                
  562.                 DelayMs(10);                                                 

  564.                 Sector_Erase(0x2000);                                                
  565.                 EEPROM_Write(0x2000,AlarmTL);               
  566.                 EEPROM_Write(0x2001,AlarmTH);       
  567.                 EEPROM_Write(0x2002,AlarmHL);       
  568.                 EEPROM_Write(0x2003,AlarmHH);               
  569.         }       
  570. }



  574. void main()
  575. {
  576.         uchar i;

  578.         LcdInit();                                                               
  579.         LcdShowInit();                                

  581.         AlarmTL=EEPROM_Read(0x2000);       
  582.         AlarmTH=EEPROM_Read(0x2001);       
  583.         AlarmHL=EEPROM_Read(0x2002);       
  584.         AlarmHH=EEPROM_Read(0x2003);       

  586.         if((AlarmTL==0)||(AlarmTL>100))       
  587.                 AlarmTL=20;
  588.         if((AlarmTH==0)||(AlarmTH>100))       
  589.                 AlarmTH=35;
  590.         if((AlarmHL==0)||(AlarmHL>100))       
  591.                 AlarmHL=40;
  592.         if((AlarmHH==0)||(AlarmHH>100))       
  593.                 AlarmHH=55;
  594.                
  595.        
  596.         while(1)
  597.         {
  598.                 ReadDhtData();                                 // 读DHT11（内）数据
  599.                 DelayMs(100);
  600.                 ReadDht_1Data();                         // 读DHT11（外）数据
  601.                 LcdGotoXY(1,2);                                
  602.                 LcdPrintNum(temp);               
  603.                 LcdGotoXY(1,11);                       
  604.                 LcdPrintNum(humi);               
  605.                
  606.                 AlarmJudge();                                        // 报警

  608.                 for(i=0;i<25;i++)
  609.                 {
  610.                         KeyScanf();                                       
  611.                         DelayMs(50);                       
  612.                 }
  613.         }
  614. }
复制代码
1 2 下一页

一周热门 更多>

相关文章