找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2892|回复: 4
收起左侧

请大神看看这程序那里有问题,编译通不过!

[复制链接]
ID:272625 发表于 2018-1-24 07:01 | 显示全部楼层 |阅读模式
  1. #include <reg52.h>
  2. //宏定义
  3. #define uc unsigned char
  4. #define ui unsigned int

  5. void display();  //声明显示函数
  6. uc code tab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff}; //数字对应显示码表
  7. uc code tab1[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};//带小数点的数字码表
  8. uc code index[]={0xef,0xdf,0xbf,0x7f};  //每位数字对应数码管显示位置
  9. uc num[8];     //num【0】-num【3】是计时用数组,4-7是范围计时用(设置10s,计时到10秒报警)
  10. uc val[10][4]; //存储的记录 [10]为记录序列,[4]为每组记录中的数字
  11. char val_index;//记录序列标志位  
  12. uc set_index,ok_flag,timing; //set_index:设置的位。ok_flag:设置状态标志,=0时是正常状态,=1是设置状态。timing:显示状态标志:=0正常显示,=1闪烁设置位
  13. bit mode=1;//运行模式,1为正向计数,0为反向计数。
  14. bit fin_flag=0;//完成标志位,当反向计数结束时,此位为高电平,触发蜂鸣器      
  15. bit set_shan;

  16. sbit beep=P3^2;         //蜂鸣器
  17. sbit key1=P3^3;         //开始停止计时数据
  18. sbit key2=P3^4;         //记录按钮/设置位置加
  19. sbit key3=P3^5;         //复位
  20. sbit key4=P3^6;         //模式切换
  21. sbit key5=P3^7;        //设置按钮

  22. void delay(ui z)                //延时函数,大约延时z ms
  23. {
  24.         ui i,j;
  25.         for(i=0;i<z;i++)
  26.         for(j=0;j<121;j++);
  27. }

  28. void init()                                //初始化
  29. {
  30.         TMOD=0x11;                        //工作方式
  31.         TH0=0x3c;
  32.         TL0=0xb0;                   //定时器0赋初值
  33.         TH1=0x3c;
  34.         TL1=0xb0;                   //定时器1赋初值
  35.         ET1=1;                           //允许中断
  36.         TR1=1;                           //定时开关
  37.         ET0=1;
  38.         TR0=0;
  39.         EA=1;                           //中断总开关

  40.         val_index=0;           //清零
  41. }

  42. void clr()                                //清除函数
  43. {
  44.         uc i;
  45.         for(i=0;i<8;i++)        //将存储的数据清零        for循环8次
  46.         num[i]=0;
  47. }

  48. void setup()                        //设置函数
  49. {
  50.         ok_flag=0xff;                //ok_flag赋值1
  51.         set_index=0;                //设置位置0
  52.         while (ok_flag)                //进入设置后,循环,直到ok_flag为0
  53.         {
  54.                  display();                //调用显示函数
  55.                 if(key1==0)          //按动KEY1设置值加1   
  56.                 {
  57.                         delay(5); //延时去抖
  58.                         if(key1==0)//再次判断按键是否按下
  59.                         {
  60.                                 if ((set_index==0)|(set_index==2)|(set_index==4)|(set_index==6))//设置个位数据时
  61.                                 {
  62.                                         num[set_index]++;                                         //数据加
  63.                                         if(num[set_index]==10)                                        //加到10
  64.                                         num[set_index]=0;                                                 //清零
  65.                                 }
  66.                                 else if((set_index==1)|(set_index==3)|(set_index==5)|(set_index==7))//设置十位数据时
  67.                                 {
  68.                                         num[set_index]++;                                                //数据加
  69.                                         if(num[set_index]==6)                                        //加到6时
  70.                                         num[set_index]=0;                                                //清零
  71.                                 }
  72.                                 while(!key1) display();                                                //按键释放
  73.                         }
  74.                 }

  75.                 if(key2==0)         //按动KEY2设置位置加1   
  76.                 {
  77.                         delay(5);//延时去抖
  78.                         if(key2==0)//再次按下按键
  79.                         {
  80.                                 set_index++;              //设置位置加
  81.                                 if(set_index==8)           //设置位置加到最后一位时
  82.                                 {
  83.                                         set_index=0;         //设置位置到0
  84.                                 }
  85.                                 while(!key2) display();      //按键释放
  86.                         }
  87.                 }
  88.                 if(key5==0)         //按动KEY5设置结束   
  89.                 {
  90.                         delay(5);//延时去抖
  91.                         if(key5==0)//再次判断按键是否按下
  92.                         {
  93.                                 ok_flag=0x00;        //ok_flag清零
  94.                                 if((num[4]!=0)||(num[5]!=0)||(num[6]!=0)||(num[7]!=0)) //如果计时时间上限设置数据不都为0时
  95.                                 {
  96.                                 num[0]=0;num[1]=0;num[2]=0;num[3]=0;mode=1;//将正计时时间清零,Mode置1,正计时
  97.                                 }
  98.                                 else if((num[4]==0)&&(num[5]==0)&&(num[6]==0)&&(num[7]==0))//如果计时时间上限设置数据都为0时
  99.                                 {
  100.                                 if((num[0]==0)&&(num[1]==0)&&(num[2]==0)&&(num[3]==0))//判断计时时间都为0
  101.                                 mode=1;                                                                          //正计时模式
  102.                                 else if((num[0]!=0)||(num[1]!=0)||(num[2]!=0)||(num[3]!=0))//判断计时时间有不为0
  103.                                 mode=0;                                                                       //倒计时模式
  104.                                 }
  105.                                 while(!key5) display();         //按键去抖
  106.                         }  
  107.                 }
  108.         }
  109. }

  110. void display()
  111. {
  112.         uc i;
  113.         if(ok_flag!=0xff)                   //不是设置状态时
  114.         {
  115.                 if(timing==0)                  
  116.                 {
  117.                         for(i=0;i<4;i++)
  118.                         {
  119.                                 P0=0xff;                    //清显示
  120.                                 P2=index[i];            //选中位
  121.                                 if(i==2)                    //如果是第二位时
  122.                                 P0=tab1[num[i]];  //显示有小数点的数据
  123.                                 else                            //不是第二位时
  124.                                 P0=tab[num[i]];   //正常显示数据
  125.                                  delay(2);                   //修改此参数可修改刷新频率   
  126.                         }
  127.                 }
  128.                 else                                           //设置时 闪烁相应位
  129.                 {
  130.                         if(set_shan==0)
  131.                         {
  132.                                 for(i=0;i<4;i++)
  133.                                 {
  134.                                         P0=0xff;
  135.                                         P2=index[i];
  136.                                         P0=tab[10];                 //熄灭
  137.                                          delay(2);                     //修改此参数可修改刷新频率  
  138.                                 }
  139.                         }
  140.                         else if(set_shan==1)
  141.                         {                                                           //点亮显示
  142.                                 for(i=0;i<4;i++)
  143.                                 {
  144.                                         P0=0xff;
  145.                                         P2=index[i];
  146.                                         if(i==2)
  147.                                         P0=tab1[num[i]];
  148.                                         else
  149.                                         P0=tab[num[i]];
  150.                                          delay(2);                   //修改此参数可修改刷新频率   
  151.                                 }
  152.                         }
  153.                 }
  154.         }
  155.         else        //设置时
  156.         {
  157.                 if(set_shan==0)
  158.                 {
  159.                         if(set_index==0)                        //设置不同位时,闪烁相应位
  160.                         {
  161.                                 for(i=0;i<4;i++)
  162.                                 {
  163.                                         if(i==0)
  164.                                         {
  165.                                                 P2=index[0];
  166.                                                 P0=tab[10];
  167.                                                  delay(2);                  //修改此参数可修改刷新频率  
  168.                                                 P0=0xff;
  169.                                         }
  170.                                         else
  171.                                         {
  172.                                                 P2=index[i];
  173.                                                 if(i==2)
  174.                                                 P0=tab1[num[i]];
  175.                                                 else
  176.                                                 P0=tab[num[i]];
  177.                                                  delay(2);                  //修改此参数可修改刷新频率  
  178.                                                 P0=0xff;
  179.                                         }
  180.                                 }
  181.                         }
  182.                         else if(set_index==1)
  183.                         {
  184.                                 for (i=0;i<4;i++)
  185.                                 {
  186.                                         if(i==1)
  187.                                         {
  188.                                                 P2=index[1];
  189.                                                 P0=tab[10];
  190.                                                  delay(2);                  //修改此参数可修改刷新频率  
  191.                                                 P0=0xff;
  192.                                         }
  193.                                         else
  194.                                         {
  195.                                                 P2=index[i];
  196.                                                 P0=tab[num[i]];
  197.                                                  delay(2);                  //修改此参数可修改刷新频率  
  198.                                                 P0=0xff;
  199.                                         }
  200.                                 }
  201.                         }
  202.                         else if(set_index==2)
  203.                         {
  204.                                 for (i=0;i<4;i++)
  205.                                 {
  206.                                         if(i==2)
  207.                                         {
  208.                                                 P2=index[2];
  209.                                                 P0=tab[10];
  210.                                                  delay(2);                  //修改此参数可修改刷新频率  
  211.                                                 P0=0xff;
  212.                                         }
  213.                                         else
  214.                                         {
  215.                                                 P2=index[i];
  216.                                                 if(i==2)
  217.                                                 P0=tab1[num[i]];
  218.                                                 else
  219.                                                 P0=tab[num[i]];
  220.                                                  delay(2);                  //修改此参数可修改刷新频率  
  221.                                                 P0=0xff;
  222.                                         }
  223.                                 }
  224.                         }
  225.                         else if(set_index==3)
  226.                         {
  227.                                 for (i=0;i<4;i++)
  228.                                 {
  229.                                         if(i==3)
  230.                                         {
  231.                                                 P2=index[3];
  232.                                                 P0=tab[10];
  233.                                                  delay(2);                  //修改此参数可修改刷新频率  
  234.                                                 P0=0xff;
  235.                                         }
  236.                                         else
  237.                                         {
  238.                                                 P2=index[i];
  239.                                                 if(i==2)
  240.                                                 P0=tab1[num[i]];
  241.                                                 else
  242.                                                 P0=tab[num[i]];
  243.                                                  delay(2);                  //修改此参数可修改刷新频率  
  244.                                                 P0=0xff;
  245.                                         }
  246.                                 }
  247.                         }
  248.                         else if(set_index==4)
  249.                         {
  250.                                 for (i=4;i<8;i++)
  251.                                 {
  252.                                         if(i==4)
  253.                                         {
  254.                                                 P2=index[0];
  255.                                                 P0=tab[10];
  256.                                                  delay(2);                  //修改此参数可修改刷新频率  
  257.                                                 P0=0xff;
  258.                                         }
  259.                                         else
  260.                                         {
  261.                                                 P2=index[i-4];
  262.                                                 if(i==6)
  263.                                                 P0=tab1[num[i]];
  264.                                                 else
  265.                                                 P0=tab[num[i]];
  266.                                                  delay(2);                  //修改此参数可修改刷新频率  
  267.                                                 P0=0xff;
  268.                                         }
  269.                                 }
  270.                         }
  271.                         else if(set_index==5)
  272.                         {
  273.                                 for (i=4;i<8;i++)
  274.                                 {
  275.                                         if(i==5)
  276.                                         {
  277.                                                 P2=index[1];
  278.                                                 P0=tab[10];
  279.                                                  delay(2);                  //修改此参数可修改刷新频率  
  280.                                                 P0=0xff;
  281.                                         }
  282.                                         else
  283.                                         {
  284.                                                 P2=index[i-4];
  285.                                                 if(i==6)
  286.                                                 P0=tab1[num[i]];
  287.                                                 else
  288.                                                 P0=tab[num[i]];
  289.                                                  delay(2);                  //修改此参数可修改刷新频率   
  290.                                                 P0=0xff;
  291.                                         }
  292.                                 }
  293.                         }
  294.                         else if(set_index==6)
  295.                         {
  296.                                 for (i=4;i<8;i++)
  297.                                 {
  298.                                         if(i==6)
  299.                                         {
  300.                                                 P2=index[2];
  301.                                                 P0=tab[10];
  302.                                                  delay(2);                  //修改此参数可修改刷新频率  
  303.                                                 P0=0xff;
  304.                                         }
  305.                                         else
  306.                                         {
  307.                                                 P2=index[i-4];
  308.                                                 if(i==6)
  309.                                                 P0=tab1[num[i]];
  310.                                                 else
  311.                                                 P0=tab[num[i]];
  312.                                                  delay(2);                  //修改此参数可修改刷新频率  
  313.                                                 P0=0xff;
  314.                                         }
  315.                                 }
  316.                         }
  317.                         else if(set_index==7)
  318.                         {
  319.                                 for (i=4;i<8;i++)
  320.                                 {
  321.                                         if(i==7)
  322.                                         {
  323.                                                 P2=index[3];
  324.                                                 P0=tab[10];
  325.                                                  delay(2);                  //修改此参数可修改刷新频率  
  326.                                                 P0=0xff;
  327.                                         }
  328.                                         else
  329.                                         {
  330.                                                 P2=index[i-4];
  331.                                                 if(i==6)
  332.                                                 P0=tab1[num[i]];
  333.                                                 else
  334.                                                 P0=tab[num[i]];
  335.                                                  delay(2);                  //修改此参数可修改刷新频率  
  336.                                                 P0=0xff;
  337.                                         }
  338.                                 }
  339.                         }
  340.                 }
  341.                 else
  342.                 {
  343.                         if(set_index<4)
  344.                         {
  345.                                 for (i=0;i<4;i++)
  346.                                 {
  347.                                         P2=index[i];
  348.                                         if(i==2)
  349.                                         P0=tab1[num[i]];
  350.                                         else
  351.                                         P0=tab[num[i]];
  352.                                          delay(2);                   //修改此参数可修改刷新频率  
  353.                                         P0=0xff;
  354.                                 }
  355.                         }
  356.                         else
  357.                         {
  358.                                 for (i=4;i<8;i++)
  359.                                 {
  360.                                         P2=index[i-4];
  361.                                         if(i==6)
  362.                                         P0=tab1[num[i]];
  363.                                         else
  364.                                         P0=tab[num[i]];
  365.                                          delay(2);                   //修改此参数可修改刷新频率  
  366.                                         P0=0xff;
  367.                                 }
  368.                         }
  369.                 }
  370.         }
  371. }

  372. void alarm()
  373. {
  374.         if((num[4]==0)&&(num[5]==0)&&(num[6]==0)&&(num[7]==0))                  //计时时间到0时
  375.         {timing=0;}                                                                                          //开始报警
  376.         else
  377.         {
  378.             if((num[4]==num[0])&&(num[6]==num[2])&&(num[5]==num[1])&&(num[7]==num[3])) //设置上限模式时,计时时间到
  379.                 {timing=1;TR0=0;}                                                        //停止计时,并闪烁显示
  380.         }
  381. }

  382. void main()
  383. {
  384.         uc h,g,k;
  385.         init();
  386.         clr();
  387.         while(1)
  388.         {
  389.                  display();                 //刷屏显示数码管  
  390.                 alarm();
  391.                 if(key1==0)             //开始/暂停按钮
  392.                 {
  393.                         delay(5);
  394.                         if(key1==0)
  395.                         {
  396.                                 TR0=~TR0;
  397.                                 while(!key1) display();
  398.                         }
  399.                 }
  400.                 if(key2==0)                   //记录按钮
  401.                 {
  402.                         delay(5);
  403.                         if(key2==0)
  404.                         {
  405.                                 if(TR0==1)       //当在运行中按下记录键则存储记录   
  406.                                 {
  407.                                         for(g=1;g<10;g++)
  408.                                         {
  409.                                                 for(k=0;k<4;k++)
  410.                                                 {
  411.                                                         val[g-1][k]=val[g][k];           //低位存储的数据向高位移一位
  412.                                                 }
  413.                                         }
  414.                                         for(h=0;h<4;h++)
  415.                                         {
  416.                                                 val[9][h]=num[h];      //将当前时间存储  
  417.                                         }
  418.                                 }
  419.                         else //在停止状态下按下记录键查看记录,按动一次序列递减一次,即查看上一次记录   
  420.                                 {
  421.                                         for(h=0;h<4;h++)
  422.                                         num[h]=val[val_index][h];   //将当前时间存储
  423.                                         val_index--;
  424.                                         if(val_index<0)
  425.                                         val_index=9;
  426.                                 }
  427.                                 while(!key2) display();                //按键释放
  428.                         }
  429.                 }
  430.                 if(key3==0)          //复位按钮
  431.                 {
  432.                         delay(5);
  433.                         if(key3==0)
  434.                         {
  435.                                 clr();                                         //将数据清零
  436.                                 while(!key3) display();              //按键释放
  437.                         }  
  438.                 }
  439.                 if((key4==0)&&(TR0==0))          /    /模式选择按钮,仅在停止状态下有效   
  440.                 {
  441.                         delay(5);
  442.                         if(key4==0)
  443.                         {
  444.                                 mode=~mode;                                 //正计时倒计时切换
  445.                                 while(!key4) display();
  446.                         }  
  447.                 }
  448.                 if((key5==0)&&(TR0==0))            //时间设置,仅在停止状态下有效
  449.                 {
  450.                         delay(5);
  451.                         if(key5==0)
  452.                         {
  453.                                 while(!key5)
  454.                                 display();
  455.                                 setup();                   //调用设置函数
  456.                         }
  457.                 }
  458.         }
  459. }  

  460. void T0_time() interrupt 1
  461. {
  462.         uc m;
  463.         TH0=0x3c;                                  //12M晶振定时器定时时间为50ms
  464.         TL0=0xb0;
  465.         m++;
  466.         if(m==20)
  467.         {
  468.                 m=0;
  469.                 if(mode==1)                        //正向计数
  470.                 {
  471.                         num[0]++;                                  //秒个位加
  472.                         if(num[0]==10)                          //秒个位加到10时
  473.                         {
  474.                                 num[0]=0;                          //个位清零
  475.                                 num[1]++;                          //秒十位加
  476.                                 if(num[1]==6)                  //秒十位加到6时
  477.                                 {
  478.                                         num[1]=0;                  //秒十位清零
  479.                                         num[2]++;                  //分个位加
  480.                                         if(num[2]==10)          //分个位加到10时
  481.                                         {
  482.                                                  num[2]=0;          //分个位清零
  483.                                                 num[3]++;          //分十位加
  484.                                                 if(num[3]==10)//分十位加到10时
  485.                                                 num[3]=0;          //分十位清零
  486.                                         }
  487.                                 }
  488.                         }
  489.                 }
  490.                 else
  491.                 {
  492.                         num[0]--;                                 //秒个位减
  493.                         if(num[0]>9)         //小于0时,该数字的最高位会变1,所以判断是否大于9        下同
  494.                         {
  495.                                 num[0]=9;
  496.                                 num[1]--;
  497.                                 if(num[1]>5)
  498.                                 {
  499.                                         num[1]=5;
  500.                                         num[2]--;
  501.                                         if(num[2]>9)
  502.                                         {
  503.                                                  num[2]=9;
  504.                                                 num[3]--;
  505.                                                 if(num[3]>9)
  506.                                                 {
  507.                                                         num[3]=0;
  508.                                                         TR0=0;
  509.                                                         fin_flag=1;
  510.                                                         clr();
  511.                                                 }
  512.                                         }
  513.                                 }
  514.                         }
  515.                 }
  516.         }
  517. }

  518. void T1_time() interrupt 3                                  //定时器1的工作函数
  519. {
  520.         uc shan,beep_stop;
  521.         TH1=0x3c;
  522.         TL1=0xb0;                                                          //重新赋初值
  523.         shan++;                                                         //闪烁变量加
  524.         if(shan==10)                                                  //加到10时(500ms)
  525.         {
  526.                 shan=0;                                                          //清零
  527.                 set_shan=~set_shan;                                  //设置的闪烁变量取反
  528.                 if((fin_flag)||(timing))               //当反向计数完成时  或计时时间到时   
  529.                 {
  530.                         beep_stop++;                        
  531.                         beep=~beep;                                     //蜂鸣器闪烁响
  532.                         if(beep_stop==10)                          //蜂鸣器响五声停止
  533.                         {
  534.                                 fin_flag=0;
  535.                                 timing=0;
  536.                                 num[4]=0;num[5]=0;num[6]=0;num[7]=0;
  537.                                 beep_stop=0;
  538.                                 beep=1;
  539.                         }
  540.                 }
  541.         }
  542. }

复制代码
回复

使用道具 举报

ID:273292 发表于 2018-1-24 10:46 | 显示全部楼层
给你调试下,发现你数组没有搞清楚,多看看书,把数组搞明白就行啦
回复

使用道具 举报

ID:222948 发表于 2018-1-24 11:10 | 显示全部楼层
num是一个数组不是省略【】,就可以看成首地址,指针不是这样用的,至少写成num或者num【i】
回复

使用道具 举报

ID:251339 发表于 2018-1-25 15:48 | 显示全部楼层
经过调试程序:发现 if((key4==0)&&(TR0==0))          /    /模式选择按钮,仅在停止状态下有效
                     此行(450)注释说明这个双斜杠没打对,文字乱入代码。把中间空格删除就好了。
回复

使用道具 举报

ID:272625 发表于 2018-4-3 00:13 | 显示全部楼层
MYSFXY 发表于 2018-1-25 15:48
经过调试程序:发现 if((key4==0)&&(TR0==0))          /    /模式选择按钮,仅在停止状态下有效
        ...

谢谢你
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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