久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索
查看: 2453|回復: 1
打印 上一主題 下一主題
收起左側(cè)

帶詳細注釋的51單片機電子秒表程序

[復制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:993062 發(fā)表于 2021-12-16 10:39 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
基于單片機電子秒表設計的一些程序編程
  1. //包含頭文件
  2. #include <reg52.h>
  3. //宏定義
  4. #define uc unsigned char
  5. #define ui unsigned int

  6. void display();        //聲明顯示函數(shù)

  7. //                                0         1    2    3    4    5    6    7    8    9
  8. uc code tab[]={0x5f,0x44,0x9d,0xd5,0xc6,0xd3,0xdb,0x45,0xdf,0xd7,0x00};        //數(shù)字對應顯示碼表
  9. uc code tab1[]={0x7f,0x64,0xbd,0xf5,0xe6,0xf3,0xfb,0x65,0xff,0xf7};                //帶小數(shù)點的數(shù)字碼表
  10. uc code index[]={0x7f,0xbf,0xdf,0xef};  //每位數(shù)字對應數(shù)碼管顯示位置

  11. uc num[8];                 //num【0】-num【3】是計時用數(shù)組,4-7是范圍計時用(設置10s,計時到10秒報警)
  12. uc val[10][4];        //存儲的記錄 [10]為記錄序列,[4]為每組記錄中的數(shù)字
  13. char val_index;        //記錄序列標志位  
  14. uc set_index,ok_flag,timing; //set_index:設置的位。ok_flag:設置狀態(tài)標志,=0時是正常狀態(tài),=1是設置狀態(tài)。timing:顯示狀態(tài)標志:=0正常顯示,=1閃爍設置位
  15. bit mode=1;                //運行模式,1為正向計數(shù),0為反向計數(shù)。
  16. bit fin_flag=0;        //完成標志位,當反向計數(shù)結(jié)束時,此位為高電平,觸發(fā)蜂鳴器     
  17. bit set_shan;
  18. uc count,beep_stop;

  19. sbit beep=P3^2;         //蜂鳴器

  20. sbit key1=P3^3;         //功能1:開始&停止計時;//功能2:倒計時數(shù)值設置位加1(倒計時數(shù)值設置模式下操作閃爍位);
  21. sbit key2=P3^4;         //功能1:記錄時間點(計時進行中按下記錄,停止計時后按下回看);//功能2:倒計時數(shù)值設置位切換(倒計時數(shù)值設置模式下操作);
  22. sbit key3=P3^5;         //功能:計時值歸零(隨時操作)
  23. sbit key4=P3^6;         //功能:正/倒計時模式切換(計時停止狀態(tài)下操作)
  24. sbit key5=P3^7;         //功能:倒計時數(shù)值設置模式(計時停止狀態(tài)下操作)

  25. void delay(ui z) //延時函數(shù),大約延時z ms
  26. {
  27.         ui i,j;
  28.         for(i=0;i<z;i++)
  29.         for(j=0;j<121;j++);
  30. }

  31. void init()                                //初始化
  32. {
  33.         TMOD=0x11;                        //工作方式
  34.         TH0=0x3c;
  35.         TL0=0xb0;                   //定時器0賦初值
  36.         TH1=0x3c;
  37.         TL1=0xb0;                   //定時器1賦初值
  38.         ET1=1;                           //允許中斷
  39.         TR1=1;                           //定時開關(guān)
  40.         ET0=1;
  41.         TR0=0;
  42.         EA=1;                           //中斷總開關(guān)

  43.         val_index=0;           //清零
  44. }

  45. void clr()                                //清除函數(shù)
  46. {
  47.         uc i;
  48.         for(i=0;i<8;i++)        //將存儲的數(shù)據(jù)清零        for循環(huán)8次
  49.         num[i]=0;
  50. }

  51. void setup()                        //設置函數(shù)
  52. {
  53.         ok_flag=0xff;                //ok_flag賦值1
  54.         set_index=0;                //設置位置0
  55.         while (ok_flag)                //進入設置后,循環(huán),直到ok_flag為0
  56.         {
  57.                  display();                //調(diào)用顯示函數(shù)
  58.                 if(key1==0)          //按動KEY1設置值加1   
  59.                 {
  60.                         delay(5); //延時去抖
  61.                         if(key1==0)//再次判斷按鍵是否按下
  62.                         {
  63.                                 if ((set_index==0)|(set_index==2)|(set_index==4)|(set_index==6))//設置個位數(shù)據(jù)時
  64.                                 {
  65.                                         num[set_index]++;                                                                                        //數(shù)據(jù)加
  66.                                         if(num[set_index]==10)                                                                                //加到10
  67.                                         num[set_index]=0;                                                                                         //清零
  68.                                 }
  69.                                 else if((set_index==1)|(set_index==3)|(set_index==5)|(set_index==7))//設置十位數(shù)據(jù)時
  70.                                 {
  71.                                         num[set_index]++;                                                                                        //數(shù)據(jù)加
  72.                                         if(num[set_index]==6)                                                                                //加到6時
  73.                                         num[set_index]=0;                                                                                        //清零
  74.                                 }
  75.                                 while(!key1) display();                                                                                        //按鍵釋放
  76.                         }
  77.                 }

  78.                 if(key2==0)         //按動KEY2設置位置加1  
  79.                 {
  80.                         delay(5);//延時去抖
  81.                         if(key2==0)//再次按下按鍵
  82.                         {
  83.                                 set_index++; //設置位置加
  84.                                 if(set_index==8)//設置位置加到最后一位時
  85.                                 {
  86.                                         set_index=0;//設置位置到0
  87.                                 }
  88.                                 while(!key2) display();//按鍵釋放
  89.                         }
  90.                 }
  91.                 if(key5==0)         //按動KEY5設置結(jié)束  
  92.                 {
  93.                         delay(5);//延時去抖
  94.                         if(key5==0)//再次判斷按鍵是否按下
  95.                         {
  96.                                 ok_flag=0x00;//ok_flag清零
  97.                                 if((num[4]!=0)||(num[5]!=0)||(num[6]!=0)||(num[7]!=0)) //如果計時時間上限設置數(shù)據(jù)不都為0時
  98.                                 {
  99.                                         num[0]=0;num[1]=0;num[2]=0;num[3]=0;mode=1;//將正計時時間清零,Mode置1,正計時
  100.                                 }
  101.                                 else if((num[4]==0)&&(num[5]==0)&&(num[6]==0)&&(num[7]==0))//如果計時時間上限設置數(shù)據(jù)都為0時
  102.                                 {
  103.                                         if((num[0]==0)&&(num[1]==0)&&(num[2]==0)&&(num[3]==0))//判斷計時時間都為0
  104.                                         mode=1;                                                                                                  //正計時模式
  105.                                         else if((num[0]!=0)||(num[1]!=0)||(num[2]!=0)||(num[3]!=0))//判斷計時時間有不為0
  106.                                         mode=0;                                                                                                           //倒計時模式
  107.                                 }
  108.                                 while(!key5) display();         //按鍵去抖
  109.                         }  
  110.                 }
  111.         }
  112. }

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

  375. void alarm()
  376. {
  377.         if((num[4]==0)&&(num[5]==0)&&(num[6]==0)&&(num[7]==0)) //計時時間到0時
  378.         {
  379.                 timing=0;
  380.         }                                                                                                         
  381.         else
  382.         {
  383.                 if((num[4]==num[0])&&(num[6]==num[2])&&(num[5]==num[1])&&(num[7]==num[3])) //設置上限模式時,計時時間到
  384.                 {
  385.                         timing=1;
  386.                         TR0=0;                  //停止計時,并閃爍顯示
  387.                 }                                                                                                                  
  388.         }
  389. }

  390. void main()
  391. {
  392.         uc h,g,k;
  393.         init();
  394.         clr();

  395.         while(1)
  396.         {
  397.                 display();                 //刷屏顯示數(shù)碼管  
  398.                 alarm();
  399.                 if(key1==0)          //開始/暫停按鈕
  400.                 {
  401.                         delay(5);
  402.                         if(key1==0)
  403.                         {
  404.                                 TR0=~TR0;
  405.                                 while(!key1) display();
  406.                         }
  407.                 }
  408.                 if(key2==0)         //記錄按鈕
  409.                 {
  410.                         delay(5);
  411.                         if(key2==0)
  412.                         {
  413.                                 if(TR0==1)//當在運行中按下記錄鍵則存儲記錄   
  414.                                 {
  415.                                         for(g=1;g<10;g++)
  416.                                         {
  417.                                                 for(k=0;k<4;k++)
  418.                                                 {
  419.                                                         val[g-1][k]=val[g][k];           //低位存儲的數(shù)據(jù)向高位移一位
  420.                                                 }
  421.                                         }
  422.                                         for(h=0;h<4;h++)
  423.                                         {
  424.                                                 val[9][h]=num[h];//將當前時間存儲
  425.                                         }
  426.                                 }
  427.                                 else//在停止狀態(tài)下按下記錄鍵查看記錄,按動一次序列遞減一次,即查看上一次記錄   
  428.                                 {
  429.                                         for(h=0;h<4;h++)
  430.                                         num[h]=val[val_index][h];//將當前時間存儲
  431.                                         val_index--;
  432.                                         if(val_index<0)
  433.                                         val_index=9;
  434.                                 }
  435.                                 while(!key2) display();                //按鍵釋放
  436.                         }
  437.                 }
  438.                 if(key3==0)          //復位按鈕
  439.                 {
  440.                         delay(5);
  441.                         if(key3==0)
  442.                         {
  443.                                 clr();                                         //將數(shù)據(jù)清零
  444.                                 while(!key3) display();         //按鍵釋放
  445.                         }  
  446.                 }
  447.                 if((key4==0)&&(TR0==0))          //模式選擇按鈕,僅在停止狀態(tài)下有效   
  448.                 {
  449.                         delay(5);
  450.                         if(key4==0)
  451.                         {
  452.                                 mode=~mode;                                 //正計時倒計時切換
  453.                                 while(!key4) display();
  454.                         }  
  455.                 }
  456.                 if((key5==0)&&(TR0==0))          //時間設置,僅在停止狀態(tài)下有效
  457.                 {
  458.                         delay(5);
  459.                         if(key5==0)
  460.                         {
  461.                                 while(!key5)
  462.                                 display();
  463.                                 setup();                   //調(diào)用設置函數(shù)
  464.                         }
  465.                 }
  466.         }
  467. }  


  468. void T0_time() interrupt 1
  469. {
  470.         uc m;
  471.         TH0=0x3c;          //12M晶振定時器定時時間為50ms
  472.         TL0=0xb0;
  473.         m++;
  474.         if(m==20)
  475.         {
  476.                 m=0;
  477.                 if(mode==1)          //正向計數(shù)
  478.                 {
  479.                         num[0]++;                                  //秒個位加
  480.                         if(num[0]==10)                          //秒個位加到10時
  481.                         {
  482.                                 num[0]=0;                          //個位清零
  483.                                 num[1]++;                          //秒十位加
  484.                                 if(num[1]==6)                  //秒十位加到6時
  485.                                 {
  486.                                         num[1]=0;                  //秒十位清零
  487.                                         num[2]++;                  //分個位加
  488.                                         if(num[2]==10)          //分個位加到10時
  489.                                         {
  490.                                                  num[2]=0;          //分個位清零
  491.                                                 num[3]++;          //分十位加
  492.                                                 if(num[3]==10)//分十位加到10時
  493.                                                 num[3]=0;          //分十位清零
  494.                                         }
  495.                                 }
  496.                         }
  497.                 }
  498.                 else
  499.                 {
  500.                         num[0]--;                                         //秒個位減
  501.                         if(num[0]>9)                                 //小于0時,該數(shù)字的最高位會變1,所以判斷是否大于9        下同
  502.                         {
  503.                                 num[0]=9;
  504.                                 num[1]--;
  505.                                 if(num[1]>5)
  506.                                 {
  507.                                         num[1]=5;
  508.                                         num[2]--;
  509.                                         if(num[2]>9)
  510.                                         {
  511.                                                  num[2]=9;
  512.                                                 num[3]--;
  513.                                                 if(num[3]>9)
  514.                                                 {
  515.                                                         num[3]=0;
  516.                                                         TR0=0;
  517.                                                         fin_flag=1;
  518.                                                         clr();
  519.                                                 }
  520.                                         }
  521.                                 }
  522.                         }
  523.                 }
  524.         }
  525. }

  526. void T1_time() interrupt 3                        //定時器1的工作函數(shù)
  527. {
  528.         uc shan,beep_stop;
  529.         TH1=0x3c;
  530.         TL1=0xb0;                                                          //重新賦初值
  531.         shan++;                                                                  //閃爍變量加
  532.         if(shan==10)                                                  //加到10時(500ms)
  533.         {
  534.                 shan=0;                                                          //清零
  535.                 set_shan=~set_shan;                                  //設置的閃爍變量取反
  536.                 if((fin_flag)||(timing))         //當反向計數(shù)完成時  或計時時間到時   
  537.                 {
  538.                         beep_stop++;                        
  539.                         beep=~beep;                                 //蜂鳴器閃爍響
  540.                         if(beep_stop==10)                 //蜂鳴器響五聲停止
  541.                         {
  542.                                 fin_flag=0;
  543.                                 timing=0;
  544.                                 num[4]=0;num[5]=0;num[6]=0;num[7]=0;
  545.                                 beep_stop=0;
  546.                                 beep=1;
  547.                         }
  548.                 }
  549.         }
  550. }
復制代碼

評分

參與人數(shù) 1黑幣 +10 收起 理由
admin + 10 共享資料的黑幣獎勵!

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏 分享淘帖 頂 踩
回復

使用道具 舉報

沙發(fā)
ID:1016637 發(fā)表于 2022-4-13 15:33 | 只看該作者
有沒有仿真圖片可以圖文來講解一下嗎?
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機教程網(wǎng)

快速回復 返回頂部 返回列表
主站蜘蛛池模板: 亚洲久草 | 亚洲丝袜天堂 | 亚洲电影一区 | 精品久久一 | 天天看天天操 | 成人在线国产 | av免费网站在线观看 | www.99热.com| 羞羞视频在线观免费观看 | 精品久久久av| www日本高清 | 中文精品视频 | 在线国产一区 | 久久久蜜臀国产一区二区 | 成人a视频 | 国产激情在线看 | 国产精品久久久久久久久婷婷 | 国产精品久久久久久久久久久久冷 | 中文字幕在线播放不卡 | 国产精品视频中文字幕 | 成人夜晚看av| 91国内精品久久 | 欧美精品99 | 日韩国产一区二区三区 | 亚洲精品三级 | 久久久久亚洲精品国产 | 久久99精品久久久久婷婷 | 欧美一区二区三区免费在线观看 | 久久久婷婷 | 精品av | 久草网址 | 人人干人人干人人干 | 91热爆在线观看 | 国产三级精品三级在线观看四季网 | 亚洲图片视频一区 | 久久精品色视频 | 男人天堂av网站 | 久久久久久国产精品三区 | 国产精品一区二区在线观看 | 一区二区在线不卡 | 亚洲精品一二三区 |