標(biāo)題: 單片機(jī)電子跑表 仿真圖 缺程序 [打印本頁]

作者: A2102179814    時間: 2022-12-9 20:22
標(biāo)題: 單片機(jī)電子跑表 仿真圖 缺程序

電子跑表 .zip

64.16 KB, 下載次數(shù): 6


作者: ministone132    時間: 2022-12-18 13:50
這個要根據(jù)實際需求編寫程序 ,編譯后的HEX文件加載到單片機(jī)中。
作者: angmall    時間: 2022-12-18 17:20
51單片機(jī)電子跑表課程設(shè)計

http://www.torrancerestoration.com/bbs/dpj-119818-1.html


  1. #include <reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uchar code Tab0[]=     //定義數(shù)碼管數(shù)組,沒有小數(shù)點
  5. {
  6.     0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
  7. };
  8. uchar code Tab1[]=      //定義數(shù)碼管數(shù)組,有小數(shù)點
  9. {            
  10.     0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef
  11. };
  12. uchar miaobiao[80];               //定義存儲秒表數(shù)組
  13. sbit K1=P3^2;                     //模式選擇鍵,本程序三種模式,分別是時間顯示、秒表、時間設(shè)置
  14. sbit K2=P3^3;                     //設(shè)置時間時加一/開始(暫停)秒表按鍵
  15. sbit K3=P3^4;                     //切換設(shè)置位/清零秒表按鍵
  16. sbit K4=P3^5;                     //秒記錄
  17. void Delay(uchar x);              //延時函數(shù)
  18. void Display0();                  //時間顯示函數(shù)
  19. void Display1();                  //秒表顯示函數(shù)
  20. void Display2();                  //時間設(shè)置顯示函數(shù)
  21. void Display3();                  //保存的秒表顯示函數(shù)
  22. void Init();                      //中斷初始化函數(shù)
  23. void Mode_K1();                   //模式切換函數(shù)
  24. void KEY_MiaoBiao();              //檢測秒表操作按鍵
  25. void KEY_Time_Set();              //檢測時間設(shè)置按鍵
  26. void KEY_MiaoBiao_keep();              //檢測秒表記錄顯示按鍵操作            
  27. uchar Hours=12,Minutes=00,seconds=00;                       //分別定義三個變量表示時、分、秒
  28. uchar Time0_bit=0;                                          //用于定時器0的溢出標(biāo)志
  29. bit Set_Time=0;                                             //設(shè)置時 閃爍時長的標(biāo)志位
  30. bit Set0=0;                                                                      //設(shè)置時間標(biāo)志,確定是設(shè)置‘分’還設(shè)置‘時’
  31. uchar K1_bit=0,m=0;                                                          //用于模式切換的標(biāo)志
  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)                                              //死循環(huán)
  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();                            //設(shè)置時間時的顯示程序,可閃爍定位
  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()                                         //設(shè)置時間時的按鍵掃描函數(shù)
  69. {
  70.     if(K1_bit==2)                                           //判斷是否為時間設(shè)置模式
  71.     {
  72.         if(K2==0)                                           //K2有按下(下同)
  73.         {
  74.             Delay(10);                                      //延時消抖(下同)
  75.             if(K2==0)                                       //再次檢測是否為誤按
  76.             {
  77.                 if(Set0==0)                 //檢測是設(shè)置‘時’還是分,Set0為0時設(shè)置‘分’,Set0為1時設(shè)置‘時’
  78.                 {
  79.                     Minutes++;              //‘分’加1
  80.                     if(Minutes==60)              //當(dāng)'分'加到60時,重新賦值0
  81.                         Minutes=0;
  82.                 }
  83.                 else
  84.                 {
  85.                     Hours++;                  //‘時’加1
  86.                     if(Hours==24)                //當(dāng)'時'加到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時設(shè)置‘分’,Set0為1時設(shè)置‘時’
  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,達(dá)到暫停或開始秒表的目的
  113.                 while(!K2);
  114.             }
  115.         }
  116.         if(K4==0)                          //當(dāng)K4按下時秒表記錄一組數(shù)據(jù)
  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)                            //當(dāng)K3按下時秒表所有數(shù)據(jù)清零,并停止定時器1
  133.             {
  134.                 uchar i;
  135.                 for(i=0;i<81;i++)
  136.                 {
  137.                     miaobiao[i]=0;              //清除所有秒記錄數(shù)據(jù)
  138.                 }
  139.                 TR1=0;                          //停止定時器1
  140.                 Miao_Biao0=0;                   //清零數(shù)據(jù)
  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)                            //當(dāng)K3按下時秒表所有數(shù)據(jù)清零,并停止定時器1
  173.             {
  174.                 uchar i;
  175.                 for(i=0;i<81;i++)
  176.                 {
  177.                     miaobiao[i]=0;              //清除所有秒記錄數(shù)據(jù)
  178.                 }
  179.                 while(!K3);
  180.             }
  181.         }
  182.     }
  183. }
  184. void Mode_K1()              //模式選擇鍵,本程序三種模式,分別是時間顯示、秒表、時間設(shè)置
  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. *************當(dāng)K1_bit為0時顯示時鐘,為1時進(jìn)入秒表,*********************
  201. *******************為2時進(jìn)入時間設(shè)置模式,3時進(jìn)入秒表記錄顯示***********
  202. ***********************************************************************/
  203.         }
  204.     }
  205. }
  206. void Time1() interrupt 3          //定時器1函數(shù)
  207. {
  208.     TH1=(65536-50000)/256;                  //重裝初值
  209.     TL1=(65536-50000)%256;
  210.     Miao_Biao0++;
  211.     if(Miao_Biao0==2)                       //以下為秒表數(shù)據(jù)處理,每兩次循環(huán)進(jìn)行一次操作
  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函數(shù)
  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)                                           //以下為時間數(shù)據(jù)處理
  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()                                       //中斷初始化函數(shù)
  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開關(guān)
  268.     TR0=1;                                        //開定時器0小開關(guān)
  269.     TH1=(65536-50000)/256;                        //定時器1裝初值,定時50ms
  270.     TL1=(65536-50000)%256;
  271.     ET1=1;                                        //開定時器1開關(guān)
  272.     TR1=0;                                        //關(guān)定時器1小開關(guān)
  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];                            //顯示秒的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示分的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示時的個位,需要加上小數(shù)點做分隔符
  297.     P1=0xfe;                                                                      //段選
  298.     Delay(10);                                                                    //延時
  299.     P0=0X00;                                                                      //消隱
  300. }
  301. void Display2()              //時間設(shè)置時的顯示函數(shù)            
  302. {
  303.     if(Set0==0)                                         //判斷是否為設(shè)置‘時’還是‘分’
  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語句實現(xiàn)分鐘以0.5秒的頻率閃爍
  314.         {
  315.             P0=Tab1[Minutes%10];              //顯示分的個位,需要加上小數(shù)點做分隔符
  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;                            //顯示分的個位,需要加上小數(shù)點做分隔符
  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];              //顯示時的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示分的個位,需要加上小數(shù)點做分隔符
  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語句實現(xiàn)‘時’鐘以0.5秒的頻率閃爍
  363.         {
  364.             P0=Tab1[Hours%10];              //顯示時的個位,需要加上小數(shù)點做分隔符
  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;                                          //顯示時的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示秒的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示分的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示時的個位,需要加上小數(shù)點做分隔符
  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];                            //顯示分的個位,需要加上小數(shù)點做分隔符
  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];                                          //顯示時的個位,需要加上小數(shù)點做分隔符
  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. }


復(fù)制代碼




作者: Hephaestus    時間: 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;
復(fù)制代碼

我也是閑的,用1982年的PL/M-51寫了一遍,測試通過。
作者: wulin    時間: 2022-12-19 08:21
來一個有程序有仿真的


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






歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1