proteus

可以帮我看看这个程序有什么问题吗？1602显示不了，还有按键都控制不了

2019-07-18 09:48发布

站内问答 / proteus
6859 3 973
  1. //宏定义
  2. #define uchar unsigned char
  3. #define uint unsigned int

  5. //包含头文件
  6. #include <reg52.h>
  7. #include <18b20.h>
  8. #include <stdlib.h>
  9. #include <intrins.h>
  10. #include <eeprom52.h>
  11. #include <lcd1602.h>
  12. #define Imax 14000    //此处为晶振为11.0592时的取值,
  13. #define Imin 8000    //如用其它频率的晶振时,
  14. #define Inum1 1450    //要改变相应的取值。
  15. #define Inum2 700
  16. #define Inum3 3000
  17. sbit K1=P1^0;
  18. sbit K2=P1^1;
  19. sbit K3=P1^2;                  //按键定义
  20. sbit BUZZ=P1^4;
  21. sbit PWM=P2^0;                  //PWM输出

  23. unsigned char Im[4]={0x00,0x00,0x00,0x00};//红外编码
  24. //uchar displaydata[4]; //显示暂存数组
  25. //全局变量
  26. char f,dang,count,count1,a_a;  //档位
  27. unsigned long m,Tc;
  28. unsigned char IrOK;          //定义红外工作变量
  29. void   jisuan();          //声明计算函数
  30. uchar mode;
  31. char sec_b=0;
  32. bit flag_b=0;
  33. uint TH,TL;                          //上下限变量
  34. uchar baif,suiji;
  35. uchar code zhuanhuan[4]={0,3,5,10};//转换数组

  37. /*ascii码*/
  38. unsigned char mun_char_table[]={"0123456789abcdef- "};
  39. unsigned char temp_table[] ={"L:00.0C  H:00.0C"};
  40. unsigned char temp_set_table[]={"D:0  T:00.0C"};

  42. void write_eeprom()                           //内部eeprom写函数
  43. {

  45.         SectorErase(0x2000);                   //清空
  46.         SectorErase(0x2c00);
  47.         SectorErase(0x2e00);
  48.         byte_write(0x2c00,TH/256);       
  49.         byte_write(0x2c01,TH%256);
  50.         byte_write(0x2c02,TL/256);
  51.         byte_write(0x2c03,TL%256);           //将上下限数据保存到eeprom
  52.         byte_write(0x2c04,dang);       
  53.         byte_write(0x2c05,mode);               
  54.         byte_write(0x2060,0x01);

  56. }

  58. /******************把数据从单片机内部eeprom中读出来*****************/
  59. void read_eeprom()                                                                                                                                  
  60. {

  62.   mode = byte_read(0x2c05);
  63.         dang = byte_read(0x2c04);
  64.         TH = byte_read(0x2c00)*256+byte_read(0x2c01);
  65.         TL = byte_read(0x2c02)*256+byte_read(0x2c03);
  66.         a_a = byte_read(0x2060);
  67.          
  68. }

  70. /**************开机自检eeprom初始化*****************/
  71. void init_eeprom()
  72. {
  73.         a_a = byte_read(0x2060);
  74.         if(a_a != 1)                //新的单片机初始单片机内问eeprom
  75.         {
  76.        
  77.                 a_a = 1;
  78.                 write_eeprom();           //保存数据
  79.         }       
  80. }

  82. /*********************************************************/
  83. //毫秒级的延时函数，time是要延时的毫秒数
  84. /*********************************************************/
  85. void delay(uint time)
  86. {
  87.         uint i,j;
  88.         for(i=0;i<time;i++)
  89.                 for(j=0;j<110;j++);
  90. }



  94. void display()                          //显示函数
  95. {
  96.                 lcd_char_write(7,1,mun_char_table[disdata[1]]);
  97.                 lcd_char_write(8,1,mun_char_table[disdata[2]]);
  98.                 lcd_char_write(10,1,mun_char_table[disdata[3]]);
  99.                 lcd_char_write(2,1,mun_char_table[dang]);
  100.                 lcd_char_write(2,0,mun_char_table[TL%1000/100]);
  101.                 lcd_char_write(3,0,mun_char_table[TL%100/10]);
  102.                 lcd_char_write(5,0,mun_char_table[TL%10]);
  103.                 lcd_char_write(11,0,mun_char_table[TH%1000/100]);
  104.                 lcd_char_write(12,0,mun_char_table[TH%100/10]);
  105.                 lcd_char_write(14,0,mun_char_table[TH%10]);
  106. }

  108. void key()                                                          //按键函数
  109. {
  110.   if(K1==0)          //按键1按下或者遥控器上的按键按下
  111.   {
  112.                  delay(5);                                                  //延时去抖

  114.                         if(K1==0) //再次判断按键按下
  115.                 {
  116.                         BUZZ=0;
  117.                         delay(20);
  118.                         BUZZ=1;                                                  //按键音
  119.                  mode++;                                                  //模式加
  120.                  if(mode>4)                                                  //模式加到大于4
  121.                  mode=0;                                                  //模式清零
  122.         //         Im[2]=0;
  123.                  IrOK=0;                                                  //变量清零
  124.                  write_eeprom();                                  //写入eeprom数据
  125.                  while(!K1);                                          //按键释放
  126.                 }
  127.   }
  128.   if(K2==0)
  129.   {
  130.    delay(5);

  132.     if(K2==0)
  133.         {
  134.                 BUZZ=0;
  135.                 delay(20);
  136.                 BUZZ=1;
  137.          if(mode==0)                                        //模式等于1时
  138.          {
  139.           TH++;                                                        //上限加
  140.           if(TH>999)                                        //上限加到大于99.9度
  141.                  
  142.           TH=TL+1;                                                //上限等于下限加一
  143.          }
  144.          else if(mode==1)                                //模式等于2时
  145.          {
  146.           TL++;                                                        //下限加
  147.           if(TL>=TH)                                        //下限加到大于等于上限
  148.           TL=TH-1;                                                //下限等于上限减一
  149.          }
  150.           else if(mode==3)                                //模式等于3时
  151.          {
  152.           dang++;                                                //档位加一
  153.           if(dang>3)                                        //档位大于3时
  154.           dang=0;                                                //档位清零
  155.          }
  156.          //Im[2]=0;
  157.          //IrOK=0;                                                //红外变量清零
  158.           write_eeprom();                                //写入eeprom数据
  159.          while(!K2);                                        //按键释放
  160.         }

  162.   }

  164.   if(K3==0)
  165.   {
  166.                  delay(5);

  168.                         if(K3==0)
  169.                 {
  170.                         BUZZ=0;
  171.                         delay(20);
  172.                         BUZZ=1;
  173.                  if(mode==0)
  174.                  {
  175.                         TH--;
  176.                         if(TH<=TL)
  177.                         TH=TL+1;
  178.                  }
  179.                  else if(mode==1)
  180.                  {
  181.                         TL--;
  182.                         if(TL>=TH)
  183.                         TL=TH-1;
  184.                  }
  185.                 else if(mode==3)
  186.                  {
  187.                          dang++;
  188.                         if(dang>3)
  189.                         dang=0;
  190.                  }
  191.                  //Im[2]=0;
  192.                  //IrOK=0;
  193.                  write_eeprom();
  194.                  while(!K3);
  195.                 }
  196.   }
  197. }
  198. void jisuan()                                                          //计算函数
  199. {
  200.   if(mode==0||mode==1||mode==2) //模式0、1、2
  201.   {
  202.     if(tvalue<=TL)                                                 //温度小于下限时
  203.         PWM=1;                                                                 //关闭输出，占空比0%
  204.         else if(tvalue>=TH)                                         //温度大于等于上限
  205.         PWM=0;                                                                 //打开输出，占空比100%
  206.         else                                                                  //其他状态时
  207.         {
  208.                 if(tvalue<(TL+(TH-TL)/2))       
  209.                 {
  210.                 baif=15;   //占空比控制变量
  211.           if(count1>baif) //根据变量判断占空比大小pwm=0.3
  212.           PWM=1;                  //关闭风扇
  213.           else
  214.           PWM=0;                  //打开风扇*/
  215.          }
  216.                 else
  217.                 {
  218.                         baif=25;   //占空比控制变量
  219.                         if(count1>baif) //根据变量判断占空比大小pwm=0.3
  220.                         PWM=1;                  //关闭风扇
  221.                         else
  222.                         PWM=0;                  //打开风扇*/       
  223.                 }
  224.         }
  225.   }
  226.   else if(mode==3)                                           //模式3时
  227.   {
  228.     if(count1>(zhuanhuan[dang]*5))           //根据档位计算出占空比
  229.         PWM=1;
  230.         else
  231.         PWM=0;
  232.   }

  234. }


  237. void main()                                                  //主函数
  238. {
  239.   /*uint count;                                          //定义变量
  240.   unsigned int i=0,j=0;
  241.   EA=1;                                                          //打开中断总开关
  242.   EX1=1;                                                  //打开外部中断1
  243.   IT1=1;                                                  //下降沿有效
  244.   TMOD=0x11;                                          //定时器工作方式

  246.   TR0=0;                                                  //关闭T0
  247.   TH0=0;
  248.   TL0=0;                                                  //初值0
  249.   ET1=1;                                                  //T1允许中断

  251.   TR1=1;                                                  //T1打开中断
  252.   TH1=0xfc;
  253.   TL1=0x18;                                                  //T1初值1ms
  254.   mode=0;                                                  //初始模式0
  255.   TH=300;
  256.   TL=200;                                                  //上下限初始值
  257.   init_eeprom();                                  //初始化eeprom
  258.   read_eeprom();                                  //读取eeprom数据
  259.           
  260.         lcd_system_reset(); //LCD1602 初始化
  261.         for (i=0;i<16;i++) lcd_char_write(i,0,temp_table[i]);  
  262.     for (j=0;j<12;j++) lcd_char_write(j,1,temp_set_table[j]);
  263. while(1)                                                  //进入循环
  264.         {            
  265.                 jisuan();                                  //计算函数
  266.                 count++;                                  //变量加
  267.                 if(count>200)                          //加到大于200
  268.                 {
  269.                         count=0;                          //清零
  270.                         TR1=0;                                  //关闭定时器T1
  271.                         read_wendu();                  //读取温度
  272.                         TR1=1;                                  //打开定时器T1
  273.                 }
  274.                 jisuan();                                  //计算函数
  275.                 display();                                  //显示函数  */
  276.         while(1)        key();                                          //按键函数
  277.                 //jisuan();                                  //计算函数
  278.                 //        }
  279. }
  280. void timer1() interrupt 3                  //定时器T1工作函数
  281. {
  282. TH1=0xfc;
  283. TL1=0x18;                                                  //重新赋初值

  285.   count1++;                                                  //加
  286.   if(count1>50)
  287.   {
  288.           count1=0;
  289.        
  290.   }
  291. }

  293. void intersvr1(void) interrupt 2                 //红外工作函数
  294. {
  295. TR0=1;
  296. Tc=TH0*256+TL0;//提取中断时间间隔时长
  297. TH0=0;
  298. TL0=0;         //定时中断重新置零
  299. if((Tc>Imin)&&(Tc<Imax))
  300. {
  301.         m=0;
  302.         f=1;

  304.         return;
  305. }       //找到启始码
  306. if(f==1)
  307. {
  308.     if(Tc>Inum1&&Tc<Inum3)
  309.     {
  310.            Im[m/8]=Im[m/8]>>1|0x80; m++;
  311.     }
  312.     if(Tc>Inum2&&Tc<Inum1)
  313.     {
  314.       Im[m/8]=Im[m/8]>>1; m++; //取码
  315.            }
  316.            if(m==32)
  317.     {
  318.       m=0;  
  319.       f=0;
  320.        
  321.       if(Im[2]==~Im[3])
  322.       {
  323.            IrOK=1;
  324.                           TR0=0;
  325.            }
  326.       else
  327.           {
  328.            IrOK=0;   //取码完成后判断读码是否正确

  330.            }
  331.     }
  332.                //准备读下一码
  333. }


  336. }
复制代码

仿真6.jpg
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
3条回答
scccx8106
1楼-- · 2019-07-18 10:24
下来看看，多谢
scccx8106
2楼-- · 2019-07-18 16:14
下来看看，多谢
JQ_Lin
3楼-- · 2019-07-18 20:30
仅看电路图，电机不能正常转动，蜂鸣器也不会正常发声。因为它们的驱动电路是错误的。


一周热门 更多>

相关文章