欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索

單片機電子跑表 仿真圖 缺程序

查看數: 2827 | 評論數: 4 | 收藏 0
關燈 | 提示:支持鍵盤翻頁<-左 右->
    組圖打開中,請稍候......
發布時間: 2022-12-9 20:22

正文摘要:

回復

ID:213173 發表于 2022-12-19 08:21
來一個有程序有仿真的


6位百分秒表 仿真.rar (128.37 KB, 下載次數: 3)

ID:883242 發表于 2022-12-18 21:43
  1. $CODE
  2. NEW$START: DO;
  3. $INCLUDE(REG51.DCL)
  4. DECLARE SEG$A LITERALLY '1';
  5. DECLARE SEG$B LITERALLY '2';
  6. DECLARE SEG$C LITERALLY '4';
  7. DECLARE SEG$D LITERALLY '8';
  8. DECLARE SEG$E LITERALLY '16';
  9. DECLARE SEG$F LITERALLY '32';
  10. DECLARE SEG$G LITERALLY '64';
  11. DECLARE SEG$DP LITERALLY '128';
  12. DECLARE SEGS(10) BYTE CONSTANT (
  13.   SEG$A+SEG$B+SEG$C+SEG$D+SEG$E+SEG$F,
  14.   SEG$B+SEG$C,
  15.   SEG$A+SEG$B+SEG$D+SEG$E+SEG$G,
  16.   SEG$A+SEG$B+SEG$C+SEG$D+SEG$G,
  17.   SEG$B+SEG$C+SEG$F+SEG$G,
  18.   SEG$A+SEG$C+SEG$D+SEG$F+SEG$G,
  19.   SEG$A+SEG$C+SEG$D+SEG$E+SEG$F+SEG$G,
  20.   SEG$A+SEG$B+SEG$C,
  21.   SEG$A+SEG$B+SEG$C+SEG$D+SEG$E+SEG$F+SEG$G,
  22.   SEG$A+SEG$B+SEG$C+SEG$D+SEG$F+SEG$G);
  23. DECLARE COUNT BYTE,DECMS WORD, VALUE WORD,DISPLAYBUFFER(7) BYTE,DEBUT BIT;
  24. DECLARE B0 BIT AT   (90H) REGISTER,
  25.   B1 BIT AT   (91H) REGISTER,
  26.   B2 BIT AT   (92H) REGISTER,
  27.   B3 BIT AT   (93H) REGISTER,
  28.   B4 BIT AT   (94H) REGISTER,
  29.   B5 BIT AT   (95H) REGISTER,
  30.   P32 BIT AT   (0B2H) REGISTER,
  31.   P33 BIT AT   (0B3H) REGISTER,
  32.   P34 BIT AT   (0B4H) REGISTER,
  33.   P35 BIT AT   (0B5H) REGISTER;
  34.   
  35. INT_T0: PROCEDURE INTERRUPT 1 USING 1;
  36.   TH0=HIGH(65535-19999);
  37.   TL0=LOW(65535-19999);
  38.   IF DEBUT THEN DECMS=DECMS+1;
  39.   COUNT=COUNT+1;
  40.   IF COUNT>7 THEN COUNT=0;
  41.   P1=0FFH;
  42.   DO CASE COUNT;
  43.     DO;
  44.       B0=0;
  45.           P0=DISPLAYBUFFER(5);
  46.         END;
  47.     DO;
  48.       B1=0;
  49.           P0=DISPLAYBUFFER(4);
  50.         END;
  51.     DO;
  52.       B2=0;
  53.           P0=DISPLAYBUFFER(3);
  54.         END;
  55.     DO;
  56.       B3=0;
  57.           P0=DISPLAYBUFFER(2);
  58.         END;
  59.     DO;
  60.       B4=0;
  61.           P0=DISPLAYBUFFER(1);
  62.         END;
  63.     DO;
  64.       B5=0;
  65.           P0=DISPLAYBUFFER(0);
  66.         END;
  67.   END;
  68.   RETURN;
  69. END INT_T0;
  70. MPROG: DO;
  71.   DECLARE I BYTE, TEMPORARY WORD;
  72.   VALUE=0;
  73.   DECMS=0;
  74.   IE=62H;
  75.   TMOD=1;
  76.   TH0=HIGH(65535-9999);
  77.   TL0=LOW(65535-9999);
  78.   TCON=10H;
  79.   ENABLE;
  80. LOOP:
  81.   CALL TIME(250);
  82.   TEMPORARY=DECMS;
  83.   DO I=0 TO 5;
  84.     DISPLAYBUFFER(I)=SEGS(LOW(TEMPORARY MOD 10));
  85.         TEMPORARY=TEMPORARY/10;
  86.   END;
  87.   IF DEBUT THEN DISPLAYBUFFER(2)=DISPLAYBUFFER(2)+SEG$DP;
  88.   ELSE DISPLAYBUFFER(2)=DISPLAYBUFFER(2)AND 7FH;
  89.   IF NOT P32 THEN DEBUT=1;
  90.   IF NOT P33 THEN DEBUT=0;
  91.   IF NOT P35 THEN DECMS=0;
  92.   GOTO LOOP;
  93. END MPROG;
  94. END NEW$START;
復制代碼

我也是閑的,用1982年的PL/M-51寫了一遍,測試通過。
ID:155507 發表于 2022-12-18 17:20
51單片機電子跑表課程設計

http://m.raoushi.com/bbs/dpj-119818-1.html


  1. #include <reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uchar code Tab0[]=     //定義數碼管數組,沒有小數點
  5. {
  6.     0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
  7. };
  8. uchar code Tab1[]=      //定義數碼管數組,有小數點
  9. {            
  10.     0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef
  11. };
  12. uchar miaobiao[80];               //定義存儲秒表數組
  13. sbit K1=P3^2;                     //模式選擇鍵,本程序三種模式,分別是時間顯示、秒表、時間設置
  14. sbit K2=P3^3;                     //設置時間時加一/開始(暫停)秒表按鍵
  15. sbit K3=P3^4;                     //切換設置位/清零秒表按鍵
  16. sbit K4=P3^5;                     //秒記錄
  17. void Delay(uchar x);              //延時函數
  18. void Display0();                  //時間顯示函數
  19. void Display1();                  //秒表顯示函數
  20. void Display2();                  //時間設置顯示函數
  21. void Display3();                  //保存的秒表顯示函數
  22. void Init();                      //中斷初始化函數
  23. void Mode_K1();                   //模式切換函數
  24. void KEY_MiaoBiao();              //檢測秒表操作按鍵
  25. void KEY_Time_Set();              //檢測時間設置按鍵
  26. void KEY_MiaoBiao_keep();              //檢測秒表記錄顯示按鍵操作            
  27. uchar Hours=12,Minutes=00,seconds=00;                       //分別定義三個變量表示時、分、秒
  28. uchar Time0_bit=0;                                          //用于定時器0的溢出標志
  29. bit Set_Time=0;                                             //設置時 閃爍時長的標志位
  30. bit Set0=0;                                                                      //設置時間標志,確定是設置‘分’還設置‘時’
  31. uchar K1_bit=0,m=0;                                                          //用于模式切換的標志
  32. uchar Miao_Biao0,Miao_Biao1,Miao_Biao2,Miao_Biao3,Miao_Biao4;                //用于秒表的變量
  33. uchar Miao_Biao11,Miao_Biao22,Miao_Biao33,Miao_Biao44;      //用于保存秒表顯示時的變量
  34. void main()
  35. {
  36.     Init();                                               //中斷初始化
  37.     while(1)                                              //死循環
  38.     {
  39.         Mode_K1();                                        //模式掃描
  40.         switch(K1_bit)                                    //模式選擇
  41.         {
  42.             case 0:
  43.                 {
  44.                     Display0();                             //顯示時間                              
  45.                     break;
  46.                 }
  47.             case 1:
  48.                 {
  49.                     Display1();                             //顯示秒表
  50.                     KEY_MiaoBiao();                         //掃描秒表操作
  51.                     break;
  52.                 }
  53.             case 2:
  54.                 {
  55.                     Display2();                            //設置時間時的顯示程序,可閃爍定位
  56.                     KEY_Time_Set();                        //掃描按鍵
  57.                     break;
  58.                 }
  59.             case 3:
  60.                 {
  61.                     Display3();                             //顯示秒表
  62.                     KEY_MiaoBiao_keep();                    //掃描秒表操作
  63.                     break;
  64.                 }
  65.         }
  66.     }
  67. }
  68. void KEY_Time_Set()                                         //設置時間時的按鍵掃描函數
  69. {
  70.     if(K1_bit==2)                                           //判斷是否為時間設置模式
  71.     {
  72.         if(K2==0)                                           //K2有按下(下同)
  73.         {
  74.             Delay(10);                                      //延時消抖(下同)
  75.             if(K2==0)                                       //再次檢測是否為誤按
  76.             {
  77.                 if(Set0==0)                 //檢測是設置‘時’還是分,Set0為0時設置‘分’,Set0為1時設置‘時’
  78.                 {
  79.                     Minutes++;              //‘分’加1
  80.                     if(Minutes==60)              //當'分'加到60時,重新賦值0
  81.                         Minutes=0;
  82.                 }
  83.                 else
  84.                 {
  85.                     Hours++;                  //‘時’加1
  86.                     if(Hours==24)                //當'時'加到24時,重新賦值0
  87.                         Hours=0;
  88.                 }
  89.                 while(!K2);//按鍵松開檢測,消除松開按鍵時的抖動干擾
  90.             }
  91.         }
  92.         if(K3==0)
  93.         {
  94.             Delay(10);
  95.             if(K3==0)
  96.             {
  97.                 Set0=~Set0;              //K3每按一次Set0取反,時分切換,Set0為0時設置‘分’,Set0為1時設置‘時’
  98.                 while(!K3);
  99.             }            
  100.         }
  101.     }
  102. }
  103. void KEY_MiaoBiao()          //檢測秒表按鍵操作
  104. {
  105.     if(K1_bit==1)                       //判斷是否為秒表模式
  106.     {
  107.         if(K2==0)
  108.         {
  109.             Delay(10);
  110.             if(K2==0)
  111.             {
  112.                 TR1=~TR1;                  //K2每按一次TR1取反,0暫停或1開始定時器1,達到暫停或開始秒表的目的
  113.                 while(!K2);
  114.             }
  115.         }
  116.         if(K4==0)                          //當K4按下時秒表記錄一組數據
  117.         {
  118.             Delay(10);
  119.             if(K4==0)
  120.             {
  121.                 miaobiao[4*m]=Miao_Biao1;
  122.                 miaobiao[4*m+1]=Miao_Biao2;
  123.                 miaobiao[4*m+2]=Miao_Biao3;
  124.                 miaobiao[4*m+3]=Miao_Biao4;
  125.                 m++;
  126.                 while(!K4);
  127.             }            
  128.         }
  129.         if(K3==0)
  130.         {
  131.             Delay(10);
  132.             if(K3==0)                            //當K3按下時秒表所有數據清零,并停止定時器1
  133.             {
  134.                 uchar i;
  135.                 for(i=0;i<81;i++)
  136.                 {
  137.                     miaobiao[i]=0;              //清除所有秒記錄數據
  138.                 }
  139.                 TR1=0;                          //停止定時器1
  140.                 Miao_Biao0=0;                   //清零數據
  141.                 Miao_Biao1=0;
  142.                 Miao_Biao2=0;
  143.                 Miao_Biao3=0;
  144.                 Miao_Biao4=0;
  145.                 m=0;                            //秒表記錄清零
  146.                 while(!K3);
  147.             }
  148.         }
  149.     }
  150. }
  151. void KEY_MiaoBiao_keep()                        //檢測秒表記錄顯示按鍵操作
  152. {
  153.     if(K1_bit==3)                               //判斷是否為秒表記錄顯示模式
  154.     {
  155.                                                                                    
  156.         if(K2==0)
  157.         {
  158.             Delay(10);
  159.             if(K2==0)
  160.             {
  161.                 m++;
  162.                 while(!K2);
  163.             }
  164.         }
  165.         Miao_Biao11=miaobiao[4*m];
  166.         Miao_Biao22=miaobiao[4*m+1];
  167.         Miao_Biao33=miaobiao[4*m+2];
  168.         Miao_Biao44=miaobiao[4*m+3];
  169.         if(K3==0)
  170.         {
  171.             Delay(10);
  172.             if(K3==0)                            //當K3按下時秒表所有數據清零,并停止定時器1
  173.             {
  174.                 uchar i;
  175.                 for(i=0;i<81;i++)
  176.                 {
  177.                     miaobiao[i]=0;              //清除所有秒記錄數據
  178.                 }
  179.                 while(!K3);
  180.             }
  181.         }
  182.     }
  183. }
  184. void Mode_K1()              //模式選擇鍵,本程序三種模式,分別是時間顯示、秒表、時間設置
  185. {
  186.     if(K1==0)
  187.     {
  188.         Delay(10);
  189.         if(K1==0)
  190.         {
  191.             K1_bit++;
  192.         //    if(K1_bit==1) m=0;
  193.             if(K1_bit==3) m=0;
  194.             if(K1_bit==4)
  195.             {
  196.                 K1_bit=0;
  197.             }
  198.             while(!K1);


  199. /***********************************************************************
  200. *************當K1_bit為0時顯示時鐘,為1時進入秒表,*********************
  201. *******************為2時進入時間設置模式,3時進入秒表記錄顯示***********
  202. ***********************************************************************/
  203.         }
  204.     }
  205. }
  206. void Time1() interrupt 3          //定時器1函數
  207. {
  208.     TH1=(65536-50000)/256;                  //重裝初值
  209.     TL1=(65536-50000)%256;
  210.     Miao_Biao0++;
  211.     if(Miao_Biao0==2)                       //以下為秒表數據處理,每兩次循環進行一次操作
  212.     {
  213.         Miao_Biao0=0;
  214.         Miao_Biao1++;                       //Miao_Biao1每加1次為100ms
  215.         if(Miao_Biao1==10)
  216.         {
  217.             Miao_Biao1=0;
  218.             Miao_Biao2++;
  219.             if(Miao_Biao2==60)
  220.             {
  221.                 Miao_Biao2=0;
  222.                 Miao_Biao3++;
  223.                 if(Miao_Biao3==60)
  224.                 {
  225.                     Miao_Biao3=0;
  226.                     Miao_Biao4++;
  227.                     if(Miao_Biao4==10)
  228.                     Miao_Biao4=0;
  229.                 }
  230.             }
  231.         }
  232.     }
  233. }
  234. void Time0() interrupt 1                                        //定時器0函數
  235. {
  236.     TH0=(65536-50000)/256;                                      //重裝初值
  237.     TL0=(65536-50000)%256;
  238.     Time0_bit++;
  239.     if((Time0_bit%10)==0)                                       //每溢出10次Time0_bit取反一次
  240.     Set_Time=~Set_Time;                                         //0.5秒閃爍一次
  241.     if(Time0_bit==20)                                           //以下為時間數據處理
  242.     {
  243.         Time0_bit=0;
  244.         seconds++;
  245.         if(seconds==60)
  246.         {
  247.             seconds=0;
  248.             Minutes++;
  249.             if(Minutes==60)
  250.             {
  251.                 Minutes=0;
  252.                 Hours++;
  253.                 if(Hours==24)
  254.                 {
  255.                     Hours=0;
  256.                 }
  257.             }
  258.         }
  259.     }
  260. }
  261. void Init()                                       //中斷初始化函數
  262. {
  263.     EA=1;                                         //開總中斷
  264.     TMOD=0X11;                                    //定時器工作方式選擇,定時器0和定時器1都選擇第1種工作方式
  265.     TH0=(65536-50000)/256;                        //定時器0裝初值,定時50ms
  266.     TL0=(65536-50000)%256;
  267.     ET0=1;                                        //開定時器0開關
  268.     TR0=1;                                        //開定時器0小開關
  269.     TH1=(65536-50000)/256;                        //定時器1裝初值,定時50ms
  270.     TL1=(65536-50000)%256;
  271.     ET1=1;                                        //開定時器1開關
  272.     TR1=0;                                        //關定時器1小開關
  273. }
  274. void Display3()              //顯示保存的秒表
  275. {
  276.     P0=Tab0[Miao_Biao11%10];                            //顯示1/10秒的個位
  277.     P1=0xdf;                                                                      //段選
  278.     Delay(10);                                                                    //延時
  279.     P0=0X00;                                                                      //消隱
  280.     P0=Tab1[Miao_Biao22%10];                            //顯示秒的個位,需要加上小數點做分隔符
  281.     P1=0xef;                                                                      //段選
  282.     Delay(10);                                                                    //延時
  283.     P0=0X00;                                                                      //消隱
  284.     P0=Tab0[Miao_Biao22/10];                            //顯示秒的十位
  285.     P1=0xf7;                                                                      //段選
  286.     Delay(10);                                                                    //延時
  287.     P0=0X00;                                                                      //消隱
  288.     P0=Tab1[Miao_Biao33%10];                            //顯示分的個位,需要加上小數點做分隔符
  289.     P1=0xfb;                                                                      //段選
  290.     Delay(10);                                                                    //延時
  291.     P0=0X00;                                                                      //消隱
  292.     P0=Tab0[Miao_Biao33/10];                            //顯示分的十位
  293.     P1=0xfd;                                                                      //段選
  294.     Delay(10);                                                                    //延時
  295.     P0=0X00;                                                                      //消隱
  296.     P0=Tab1[Miao_Biao44%10];                            //顯示時的個位,需要加上小數點做分隔符
  297.     P1=0xfe;                                                                      //段選
  298.     Delay(10);                                                                    //延時
  299.     P0=0X00;                                                                      //消隱
  300. }
  301. void Display2()              //時間設置時的顯示函數            
  302. {
  303.     if(Set0==0)                                         //判斷是否為設置‘時’還是‘分’
  304.     {
  305.         P0=Tab0[seconds%10];                            //顯示秒的個位
  306.         P1=0xdf;                                                                      //段選
  307.         Delay(10);                                                                    //延時
  308.         P0=0X00;                                                                      //消隱
  309.         P0=Tab0[seconds/10];                            //顯示秒的十位
  310.         P1=0xef;                                                                      //段選
  311.         Delay(10);                                                                    //延時
  312.         P0=0X00;                                                                      //消隱
  313.         if(Set_Time)                                                        //這個if語句實現分鐘以0.5秒的頻率閃爍
  314.         {
  315.             P0=Tab1[Minutes%10];              //顯示分的個位,需要加上小數點做分隔符
  316.             P1=0xf7;                                                                      //段選
  317.             Delay(10);                                                                    //延時
  318.             P0=0X00;                                                                      //消隱
  319.             P0=Tab0[Minutes/10];                            //顯示分的十位
  320.             P1=0xfb;                                                                      //段選
  321.             Delay(10);                                                                    //延時
  322.             P0=0X00;                                                                      //消隱
  323.         }
  324.         else
  325.         {
  326.             P0=0x00;                            //顯示分的個位,需要加上小數點做分隔符
  327.             P1=0xf7;                                                                      //段選
  328.             Delay(10);                                                                    //延時
  329.             P0=0X00;                                                                      //消隱
  330.             P0=0x00;                                      //顯示分的十位
  331.             P1=0xfb;                                                                      //段選
  332.             Delay(10);                                                                    //延時
  333.             P0=0X00;                                                                      //消隱
  334.         }
  335.         P0=Tab1[Hours%10];              //顯示時的個位,需要加上小數點做分隔符
  336.         P1=0xfd;                                                                      //段選
  337.         Delay(10);                                                                    //延時
  338.         P0=0X00;                                                                      //消隱
  339.         P0=Tab0[Hours/10];                            //顯示時的十位
  340.         P1=0xfe;                                                                      //段選
  341.         Delay(10);                                                                    //延時
  342.         P0=0X00;                                                                      //消隱
  343.     }
  344.     else                                          //‘時’鐘閃爍
  345.     {
  346.         P0=Tab0[seconds%10];                            //顯示秒的個位
  347.         P1=0xdf;                                                                      //段選
  348.         Delay(10);                                                                    //延時
  349.         P0=0X00;                                                                      //消隱
  350.         P0=Tab0[seconds/10];                            //顯示秒的十位
  351.         P1=0xef;                                                                      //段選
  352.         Delay(10);                                                                    //延時
  353.         P0=0X00;                                                                      //消隱
  354.         P0=Tab1[Minutes%10];                            //顯示分的個位,需要加上小數點做分隔符
  355.         P1=0xf7;                                                                      //段選
  356.         Delay(10);                                                                    //延時
  357.         P0=0X00;                                                                      //消隱
  358.         P0=Tab0[Minutes/10];                            //顯示分的十位
  359.         P1=0xfb;                                                                      //段選
  360.         Delay(10);                                                                    //延時
  361.         P0=0X00;                                                                      //消隱
  362.         if(Set_Time)                                                        //這個if語句實現‘時’鐘以0.5秒的頻率閃爍
  363.         {
  364.             P0=Tab1[Hours%10];              //顯示時的個位,需要加上小數點做分隔符
  365.             P1=0xfd;                                                                      //段選
  366.             Delay(10);                                                                    //延時
  367.             P0=0X00;                                                                      //消隱
  368.             P0=Tab0[Hours/10];                            //顯示時的十位
  369.             P1=0xfe;                                                                      //段選
  370.             Delay(10);                                                                    //延時
  371.             P0=0X00;                                                                      //消隱
  372.         }
  373.         else
  374.         {
  375.             P0=0x00;                                          //顯示時的個位,需要加上小數點做分隔符
  376.             P1=0xFF;                                          //段選
  377.             Delay(10);                                        //延時
  378.             P0=0X00;                                          //消隱
  379.             P0=0X00;                                          //顯示時的十位
  380.             P1=0xFF;                                          //段選
  381.             Delay(10);                                        //延時
  382.             P0=0X00;                                          //消隱                                   
  383.         }                           
  384.     }
  385. }
  386. void Display1()              //顯示秒表
  387. {
  388.     P0=Tab0[Miao_Biao1%10];                            //顯示1/10秒的個位
  389.     P1=0xdf;                                                                      //段選
  390.     Delay(10);                                                                    //延時
  391.     P0=0X00;                                                                      //消隱
  392.     P0=Tab1[Miao_Biao2%10];                            //顯示秒的個位,需要加上小數點做分隔符
  393.     P1=0xef;                                                                      //段選
  394.     Delay(10);                                                                    //延時
  395.     P0=0X00;                                                                      //消隱
  396.     P0=Tab0[Miao_Biao2/10];                            //顯示秒的十位
  397.     P1=0xf7;                                                                      //段選
  398.     Delay(10);                                                                    //延時
  399.     P0=0X00;                                                                      //消隱
  400.     P0=Tab1[Miao_Biao3%10];                            //顯示分的個位,需要加上小數點做分隔符
  401.     P1=0xfb;                                                                      //段選
  402.     Delay(10);                                                                    //延時
  403.     P0=0X00;                                                                      //消隱
  404.     P0=Tab0[Miao_Biao3/10];                            //顯示分的十位
  405.     P1=0xfd;                                                                      //段選
  406.     Delay(10);                                                                    //延時
  407.     P0=0X00;                                                                      //消隱
  408.     P0=Tab1[Miao_Biao4%10];                            //顯示時的個位,需要加上小數點做分隔符
  409.     P1=0xfe;                                                                      //段選
  410.     Delay(10);                                                                    //延時
  411.     P0=0X00;                                                                      //消隱
  412. }
  413. void Display0()              //顯示時鐘
  414. {
  415.     P0=Tab0[seconds%10];                            //顯示秒的個位
  416.     P1=0xdf;                                                                      //段選
  417.     Delay(10);                                                                    //延時
  418.     P0=0X00;                                                                      //消隱
  419.     P0=Tab0[seconds/10];                            //顯示秒的十位
  420.     P1=0xef;                                                                      //段選
  421.     Delay(10);                                                                    //延時
  422.     P0=0X00;                                                                      //消隱
  423.     P0=Tab1[Minutes%10];                            //顯示分的個位,需要加上小數點做分隔符
  424.     P1=0xf7;                                                                      //段選
  425.     Delay(10);                                                                    //延時
  426.     P0=0X00;                                                                      //消隱
  427.     P0=Tab0[Minutes/10];                            //顯示分的十位
  428.     P1=0xfb;                                                                      //段選
  429.     Delay(10);                                                                    //延時
  430.     P0=0X00;                                                                      //消隱
  431.     P0=Tab1[Hours%10];                                          //顯示時的個位,需要加上小數點做分隔符
  432.     P1=0xfd;                                                                      //段選
  433.     Delay(10);                                                                    //延時
  434.     P0=0X00;                                                                      //消隱
  435.     P0=Tab0[Hours/10];                                          //顯示時的十位
  436.     P1=0xfe;                                                                      //段選
  437.     Delay(10);                                                                    //延時
  438.     P0=0X00;                                                                      //消隱
  439. }
  440. void Delay(uchar x)          //延時
  441. {
  442.     uchar i,j;
  443.     for(i=x;i>0;i--)
  444.                   for(j=110;j>0;j--);
  445. }


復制代碼



ID:476772 發表于 2022-12-18 13:50
這個要根據實際需求編寫程序 ,編譯后的HEX文件加載到單片機中。

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表