标题: 关于8051单片机开发板秒表程序问题，数组没办法初始化 [打印本页]
作者: 凛夏寒烟    时间: 2019-1-1 19:19
标题: 关于8051单片机开发板秒表程序问题，数组没办法初始化
求助QAQ，一直是这样查了好久看不出来问题。数组没办法初始化。。谱中的板子

  1. #include <reg52.h>
  2. typedef unsigned char u8;
  3. typedef unsigned int u16;
  4. typedef unsigned long u32;

  6. sbit LSA = P2^2;        //38译码器引脚编号，选择数码管
  7. sbit LSB = P2^3;
  8. sbit LSC = P2^4;
  9. sbit number = P0;    //发送转换表(段码)
  10. sbit key1 = P3^1;    //开始/暂停
  11. sbit key2 = P3^0;    //复位
  12. sbit key3 = P3^2;    //
  13. sbit key4 = P3^3;    //

  15. u8 code smgduan[17] = {
  16.     0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
  17.     0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71
  18.     };//数码管转换表

  20. u8 LedBuff[8] = {
  21.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  22.     } ;//数码管缓冲区
  23. u8 KeySt[4] = {
  24.     1, 1, 1, 1
  25.     };//按键电平状态储存区

  27. bit StopwatchRunning = 1;    //秒表是否运行（确定是否暂停）
  28. bit StopwatchRefresh = 1;    //秒表是否要刷新
  29. u8    DecimalPart = 0;        //计数小数部分
  30. u16    IntegerPart = 0;        //计数整数部分
  31. u8    T0RH = 0;                //T0重装高位
  32. u8    T0RL = 0;                //T0重装低位
  33. void ConfigTimer0(u16 ms); //配置定时器
  34. void StopwatchDisplay(); //显示函数（数字分割显示）
  35. void KeyDriver(); //检测按键，执行指令（主函数中调用）

  37. void main()
  38. {
  39.     EA = 1;    //打开总中断
  40.     ConfigTimer0(2);    //定时器2ms

  42.     while(1)
  43.     {
  44.         if(StopwatchRefresh)   //是否更新数码管显示
  45.         {
  46.             StopwatchRefresh = 0;
  47.             StopwatchDisplay();
  48.         }
  49.         KeyDriver();    //调用按键驱动
  50.     }
  51. }
  52. /*函数部分*/
  53. void ConfigTimer0(u16 ms)//配置定时器
  54. {
  55.     u32 tmp;
  56.    
  57.     tmp = 12000000 / 12;
  58.     tmp = (tmp * ms) / 1000;
  59.     tmp = 65536 - tmp;
  60.     tmp += 18;
  61.     T0RH = (u8)(tmp >> 8);
  62.     T0RL = (u8)tmp;
  63.     TMOD &= 0XF0;    //仅改变后四位（置零）
  64.     TMOD |= 0X01;
  65.     TH0 = T0RH;
  66.     TL0 = T0RL;
  67.     ET0 = 1;
  68.     TR0 = 1;        
  69. }
  70. void StopwatchDisplay()//显示函数（数字分割显示）
  71. {
  72.     signed char i;
  73.     u8 buf[4];    //

  75.     LedBuff[0] = smgduan[DecimalPart % 10];     //小数转换
  76.     LedBuff[1] = smgduan[DecimalPart / 10];
  77.     buf[0] = IntegerPart % 10;
  78.     buf[1] = (IntegerPart / 10) % 10;
  79.     buf[2] = (IntegerPart / 100) % 10;
  80.     buf[3] = (IntegerPart / 1000) % 10;
  81.     for(i = 3; i >= 1; i --) //整数高位0转换为空
  82.     {
  83.         if(buf[i] == 0)
  84.         {
  85.             LedBuff[i + 2] = 0XFF;
  86.         }
  87.         else break;
  88.     }
  89.     for( ; i >= 0; i --)    //整数转换
  90.     {
  91.         LedBuff[i + 2] = smgduan[buf[i]];
  92.     }
  93.     LedBuff[2] &= 0X80;     //小数点
  94. }
  95. void StopwatchAction()//秒表的启动与暂停
  96. {
  97.     if (StopwatchRunning)    //已启动则停止
  98.         StopwatchRunning = 0;
  99.     else                     //未启动则启动
  100.         StopwatchRunning = 1;
  101. }
  102. void StopwatchReset()//秒表复位
  103. {
  104.     StopwatchRunning = 0;
  105.     DecimalPart = 0;
  106.     IntegerPart = 0;
  107.     StopwatchRefresh = 1;
  108. }
  109. void KeyDriver()//检测按键，执行指令（主函数中调用）
  110. {
  111.     u8 i;
  112.     static u8 backup[4] = {1, 1, 1 , 1};//键值对比样本   

  114.     for(i = 0; i < 4; i ++)
  115.     {
  116.         if(backup[i] != KeySt[i])
  117.         {
  118.             if(backup[i] != 0)
  119.             {
  120.                 if(i == 1)
  121.                 {
  122.                     StopwatchReset();
  123.                 }
  124.                 else if(i == 2)
  125.                 {
  126.                     StopwatchAction();
  127.                 }
  128.             }
  129.             backup[i] = KeySt[i];    //刷新备份，作为下次判定样本   
  130.         }
  131.     }
  132. }
  133. void KeyScan()//按键扫描，定时中断调用
  134. {
  135.     u8 i;
  136.     static u8 keybuf[4]    = {
  137.         0xFF, 0xFF, 0xFF, 0xFF
  138.     };
  139.     keybuf[0] = (keybuf[0] << 1) | key1;  //键值输入
  140.     keybuf[1] = (keybuf[1] << 1) | key2;
  141.     keybuf[2] = (keybuf[2] << 1) | key3;
  142.     keybuf[3] = (keybuf[3] << 1) | key4;

  144.     for(i = 0; i < 4; i ++)
  145.     {
  146.         if(keybuf[i] == 0X00)
  147.         {
  148.             KeySt[i] = 0;
  149.         }
  150.         else if(keybuf == 0XFF)
  151.         {
  152.             KeySt[i] = 1;
  153.         }
  154.     }

  156. }
  157. void LedScan()//数码管扫描，定时中断调用
  158. {
  159.     static u8 i = 0;

  161.     number = 0X00;
  162.     //LS = (LS & 0XE3) | (i << 2);
  163.     for(i = 0;i < 5;i++)
  164.     {
  165.         switch(i)     //位选，选择点亮的数码管，
  166.         {
  167.             case(0):
  168.                 LSA=0;LSB=0;LSC=0; break;//显示第0位
  169.             case(1):
  170.                 LSA=1;LSB=0;LSC=0; break;//显示第1位
  171.             case(2):
  172.                 LSA=0;LSB=1;LSC=0; break;//显示第2位
  173.             case(3):
  174.                 LSA=1;LSB=1;LSC=0; break;//显示第3位
  175.             case(4):
  176.                 LSA=0;LSB=0;LSC=1; break;//显示第4位
  177.             case(5):
  178.                 LSA=1;LSB=0;LSC=1; break;//显示第5位
  179.             case(6):
  180.                 LSA=0;LSB=1;LSC=1; break;//显示第6位
  181.             case(7):
  182.                 LSA=1;LSB=1;LSC=1; break;//显示第7位   
  183.         }
  184.     }
  185.     P0 = LedBuff[i];
  186.     //if(i < 5) i ++;
  187.     //else i = 0;

  189. }
  190. void StopwatchCount()//秒数统计
  191. {
  192.     if(StopwatchRunning)
  193.     {
  194.         DecimalPart ++;
  195.         if(DecimalPart >= 100)
  196.         {
  197.             DecimalPart = 0;
  198.             IntegerPart ++;
  199.             if(IntegerPart > 10000)
  200.             {
  201.                 IntegerPart = 0;
  202.             }   
  203.         }
  204.         StopwatchRefresh = 1;  //提醒刷新
  205.     }
  206. }
  207. void InterruptTimer0() interrupt 1 //中断函数
  208. {
  209.     static u8 tmr10ms = 0;
  210.    
  211.     TH0 = T0RH;
  212.     TL0 = T0RL;
  213.     LedScan();
  214.     KeyScan();
  215.     tmr10ms ++;
  216.     if(tmr10ms >= 5) //10ms记一次数
  217.     {
  218.         tmr10ms = 0;
  219.         StopwatchCount();
  220.     }   
  221. }
复制代码


作者: HC6800-ES-V2.0    时间: 2019-1-2 08:23
一点看法吧——程序我还没有读通
第一：你照片上的右四位数码管的点亮的问题，不是什么数组初始化问题，是消隐问题
            case(7):
                LSA=1;LSB=1;LSC=1; break;//显示第7位   
        }
    }
    P0 = LedBuff[i];
                j=10;                                                 //扫描间隔时间设定
                while(j--);       
                P0=0x00;//消隐
我在你的显示函数中加点东西，就不亮了，就只有最左的数码管是亮的。
第二：看你的程序结构(虽然没全部读通)，但你的显示和按键函数都放在中断里，是很不好的——一是让你的定时很不准确，二是显示和按键在不中断时不能执行——我有你同样的板子，按键根本没用，长按都不行，具体原因还没找到，但这个结构很不好，其实就是编程思路问题。
我这里有别人的一个程序，给你看看，功能是完整的哦——一键秒表

//上电待令，按键k3计时开始，再按计时停止，再按清0，再按开始，周而复始。
#include <reg51.h>
#define uint unsigned int
#define uchar unsigned char
sbit LSA=P2^2;
sbit LSB=P2^3;
sbit LSC=P2^4;//连接译码器，选择点亮的数码管
sbit k3=P3^2;//外部中断按键
uchar code table[]={
        0x3f,0x06,0x5b,0x4f,
        0x66,0x6d,0x7d,0x07,
        0x7f,0x6f,0x77,0x7c,
        0x39,0x5e,0x79,0x71};
uchar Cntus=0,Cnt100ms,Cnt1s=0;//中断计时变量
bit zantin=0;                                        //暂停标志


/***********定时器初始化程序****************/
void Timer0Init(void)                //2500微秒@12.000MHz
{
        TMOD= 0x01;                //设置定时器模式
        TL0 = 0x3C;                //设置定时初值
        TH0 = 0xF6;                //设置定时初值
        TF0 = 0;                //清除TF0标志
        TR0 = 1;                //定时器0开始计时
        EA=1;                        //开总中断
        ET0=1;                //开定时器0中断
}
/***********按键扫描程序****************/
void keyscan()        
{
        static uint count2=0,count1=0;        //计数变量                        
        static bit key_sign=0;                                //按键状态标志
        if(k3==0)                                //检测输入如果为0
        {
                count1++;                                        //计数延时消抖
                if((count1>=500)&&(key_sign==0))//检测按键如果为0
                {                        
                        key_sign=1;                //按键状态标志置1，防止重复响应
                        count2++;
                        if(count2>=3)
                                count2=0;
                        switch(count2)
                        {
                                case 0:        Cntus=0;
                                                Cnt100ms=0;
                                                Cnt1s=0;        break;//清0
                                case 1:        zantin=1;   break;//计时
                                case 2:        zantin=0;        break;//暂停
                        }               
                }
        }
        else
        {
                count1=0;                                //计数变量清0
                key_sign=0;                                //按键状态标志清0
        }
}
void display()//显示程序
{
        static uchar  i=0;
        P0=0x00;//消隐
        switch(i)
        {
                case(0):
                LSA=0;LSB=1;LSC=1;P0=table[Cnt1s/10];i++; break;//显示第5位
                case(1):
                LSA=1;LSB=0;LSC=1;P0=table[Cnt1s%10]|0x80;i++; break;//显示第6位
                case(2):
                LSA=0;LSB=0;LSC=1;P0=table[Cnt100ms];i=0; break;//显示第7位
        }
}
/***************主程序****************/
void main()
{
        Timer0Init();                                //定时器初始化
        while(1)
        {
                keyscan();                                //按键扫描
        }
}
/**************中断服务程序*****************/
void timer0() interrupt        1//2500微秒@11.0592MHz
{
        TL0 = 0x00;                //设置定时初值
        TH0 = 0xF7;                //设置定时初值
        Cntus++;                                        //中断变量Cntus自+1
        if(Cntus>=40)                                //10ms
        {
                Cntus=0;                                //清0
                if(zantin==1)                        //暂停/启动
                        Cnt100ms++;                        //毫秒计数
                if(Cnt100ms>=10)
                {
                        Cnt100ms=0;
                        Cnt1s++;                                //秒计数
                        if(Cnt1s>=60)
                                Cnt1s=0;
                }
        }
        display();                                        //显示程序
}
作者: 凛夏寒烟    时间: 2019-1-3 21:19
HC6800-ES-V2.0 发表于 2019-1-2 08:23
一点看法吧——程序我还没有读通
第一：你照片上的右四位数码管的点亮的问题，不是什么数组初始化问题，是 ...

我把程序改了下，可是按键时只有第一次按下有作用，有时复位键有作用，我怀疑是按键消抖作用需要时间太长，和扫描形成了时间差，您觉得是不是有这样的可能。普中的板子是会在长按按键一段时间后自动取消置高电平的吗？
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. typedef unsigned char u8;
  5. typedef unsigned int u16;
  6. typedef unsigned long u32;

  8. sbit LS = P2;        //38译码器引脚编号，选择数码管
  9. sbit number = P0;    //发送转换表(段码)
  10. sbit key1 = P3^1;    //复位
  11. sbit key2 = P3^0;    //开始/暂停
  12. sbit key3 = P3^2;    //
  13. sbit key4 = P3^3;    //

  15. u8 code smgduan[17] = {
  16.     0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
  17.     0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71
  18.     };//数码管转换表

  20. u8 LedBuff[8] = {
  21.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  22.     } ;//数码管缓冲区
  23. u8 KeySt[4] = {
  24.     1, 1, 1, 1
  25.     };//按键电平状态储存区

  27. bit StopwatchRunning = 0;    //秒表是否运行（确定是否暂停）
  28. bit StopwatchRefresh = 1;    //秒表是否要刷新
  29. u8    mseconds = 0;        //计数毫秒部分
  30. u8    seconds = 0;         //计数秒部分
  31. u8          minutes = 0;                   //计数分钟部分
  32. u8    T0RH = 0;                //T0重装高位
  33. u8    T0RL = 0;                //T0重装低位
  34. void ConfigTimer0(u16 ms); //配置定时器
  35. void StopwatchDisplay(); //显示函数（数字分割显示）
  36. void KeyDriver(); //检测按键，执行指令（主函数中调用）
  37. void LedScan();
  38. void KeyScan();
  39. void main()
  40. {
  41.     EA = 1;    //打开总中断
  42.     ConfigTimer0(2);    //定时器2ms

  44.     while(1)
  45.     {
  46.         if(StopwatchRefresh)   //是否更新数码管显示
  47.         {
  48.             StopwatchRefresh = 0;
  49.             StopwatchDisplay();
  50.         }
  51.                 LedScan();
  52.                 KeyScan();
  53.         KeyDriver();    //调用按键驱动
  54.     }
  55. }
  56. /*函数部分*/
  57. void ConfigTimer0(u16 ms)//配置定时器
  58. {
  59.     u32 tmp;
  60.    
  61.     tmp = 11059260 / 12;
  62.     tmp = (tmp * ms) / 1000;
  63.     tmp = 65536 - tmp;
  64.     tmp += 18;                 //时间补偿
  65.     T0RH = (u8)(tmp >> 8);
  66.     T0RL = (u8)tmp;
  67.     TMOD &= 0XF0;    //仅改变后四位（置零）
  68.     TMOD |= 0X01;
  69.     TH0 = T0RH;
  70.     TL0 = T0RL;
  71.     ET0 = 1;
  72.     TR0 = 1;        
  73. }
  74. void StopwatchDisplay()//显示函数（数字分割显示）
  75. {
  76.     signed char i;
  77.     u8 buf[2]; u8 minbuf[2];   

  79.     LedBuff[0] = smgduan[mseconds % 10];     //毫秒转换
  80.     LedBuff[1] = smgduan[mseconds / 10];
  81.     buf[1] = seconds % 10;
  82.     buf[2] = (seconds / 10) % 10;
  83.     minbuf[1] = (minutes) % 10;
  84.     minbuf[2] = (minutes / 10) % 10;
  85.     for(i = 1; i < 3; i ++) //秒位数字转换0
  86.     {
  87.         if(buf[i] == 0)
  88.         {
  89.             LedBuff[i + 2] = 0X00;
  90.         }
  91.         else break;
  92.     }
  93.         for(i = 1; i < 3; i ++) //分位数字转换0
  94.         {
  95.                 if(minbuf[i] == 0)
  96.         {
  97.             LedBuff[i + 5] = 0X00;
  98.         }
  99.         else break;       
  100.         }
  101.     for(i = 1 ; i < 3; i ++)    //秒和分位数字转换
  102.     {
  103.         LedBuff[i + 2] = smgduan[buf[i]];
  104.                 LedBuff[i + 5] = smgduan[minbuf[i]];       
  105.     }
  106.     LedBuff[2] = 0X40;     //"-"符号显示
  107.         LedBuff[5] = 0x40;
  108. }
  109. void StopwatchAction()//秒表的启动与暂停
  110. {
  111.     if (StopwatchRunning)    //已启动则停止
  112.         StopwatchRunning = 0;
  113.     else                     //未启动则启动
  114.         StopwatchRunning = 1;
  115. }
  116. void StopwatchReset()//秒表复位
  117. {
  118.     StopwatchRunning = 0;
  119.     mseconds = 0;
  120.     seconds = 0;
  121.         minutes = 0;
  122.     StopwatchRefresh = 1;
  123. }
  124. void KeyDriver()//检测按键，执行指令（主函数中调用）
  125. {
  126.     static u8 i;
  127.     static u8 backup[4] = {1, 1, 1 , 1};//键值对比样本   

  129.     for(i = 0; i < 4; i ++)
  130.     {
  131.         if(backup[i] != KeySt[i])
  132.         {
  133.             if(backup[i] != 0)
  134.             {
  135.                 if(i == 0)
  136.                 {
  137.                     StopwatchReset();        //重置
  138.                 }
  139.                 else if(i == 1)
  140.                 {
  141.                     StopwatchAction();        //开始/暂停
  142.                 }
  143.             }
  144.             else if(i == 1)
  145.             {
  146.                 StopwatchAction();        //开始/暂停
  147.             }
  148.                         backup[i] = KeySt[i];    //刷新备份，作为下次判定样本   
  149.         }
  150.     }
  151. }
  152. void KeyScan()//按键扫描
  153. {
  154.         u8  i = 0;
  155.     static u8 keybuf[4]    = {
  156.         0xFF, 0xFF, 0xFF, 0xFF
  157.     };
  158.         keybuf[0] = (keybuf[0] << 1) | key1;  //键值输入,8次分位输入，消抖
  159.     keybuf[1] = (keybuf[1] << 1) | key2;
  160.     keybuf[2] = (keybuf[2] << 1) | key3;
  161.     keybuf[3] = (keybuf[3] << 1) | key4;

  163.     for(i = 0; i < 4; i ++)
  164.     {
  165.         if(keybuf[i] == 0X00)
  166.         {
  167.             KeySt[i] = 0;
  168.         }
  169.         else if(keybuf == 0XFF)
  170.         {
  171.             KeySt[i] = 1;
  172.         }
  173.     }
  174. }
  175. void LedScan()//数码管扫描
  176. {
  177.     u8 i = 0;
  178.         for( ; i < 8; i ++)
  179.     {
  180.                 P2 = (P2 & 0XE3) | (i << 2);
  181.                 P0 = LedBuff[i];
  182.                 _nop_();                                        //延时两个机器周期
  183.                 _nop_();
  184.                 P0 = 0x00;
  185.         }
  186. }
  187. void StopwatchCount()//秒数统计
  188. {
  189.     if(StopwatchRunning)
  190.     {
  191.         mseconds ++;
  192.         if(mseconds >= 100)
  193.         {
  194.             mseconds = 0;
  195.             seconds ++;
  196.             if(seconds >= 60)
  197.             {
  198.                 seconds = 0;
  199.                                 minutes ++;
  200.             }
  201.                         if(minutes >= 60)
  202.                         {
  203.                                         minutes = 0;
  204.                         }   
  205.         }
  206.         StopwatchRefresh = 1;  //提醒刷新
  207.     }
  208. }
  209. void InterruptTimer0() interrupt 1 //中断函数
  210. {
  211.     static u8 tmr10ms = 0;
  212.    
  213.     TH0 = T0RH;
  214.     TL0 = T0RL;
  215.     tmr10ms ++;
  216.     if(tmr10ms >= 5) //10ms记一次数
  217.     {
  218.         tmr10ms = 0;
  219.         StopwatchCount();
  220.     }   
  221. }
复制代码
作者: 凛夏寒烟    时间: 2019-1-3 21:27
HC6800-ES-V2.0 发表于 2019-1-2 08:23
一点看法吧——程序我还没有读通
第一：你照片上的右四位数码管的点亮的问题，不是什么数组初始化问题，是 ...

而且复位之后无法重新启动，求帮助
作者: wulin    时间: 2019-1-4 11:21
凛夏寒烟 发表于 2019-1-3 21:27
而且复位之后无法重新启动，求帮助

给你改写成单键操作8位24小时百分秒表，有详细注释，应该能看得懂，经仿真无误。

#include <AT89X52.H>

#define number P0
#define wela P2
typedef unsigned int u16 ;
typedef unsigned char u8 ;

sbit key1=P3^0;
//sbit key2=P3^1;
//sbit wela_A=P2^2;       
//sbit wela_B=P2^3;       
//sbit wela_C=P2^4;       

u8 code smgduan[16] = {
    0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07,
    0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71
    };//数码管转换表

u8 LedBuff[8];//数码管缓冲区

u8 Cntus=0,Cnt10ms=0,Cnt1s=0,Cnt1min=0,Cnthour=0;                //中断计时变量

bit suspend=0;                                        //暂停标志
void LedScan();                                        //显示程序声明
void keyscan();                                        //按键扫描程序声明

/***********按键扫描程序****************/
void keyscan()       
{
        static u8 count2=0,count1=0;        //计数变量                       
        static bit key_sign=0;                                        //按键状态标志
        if(key1==0)                                //检测输入如果为0
        {
                count1++;                                        //计数延时消抖
                if((count1>=100)&&(key_sign==0))//检测按键如果为0
                {                       
                        key_sign=1;                //按键状态标志置1，防止重复响应
                        count2++;
                        if(count2>=3)
                                count2=0;
                        switch(count2)
                        {
                                case 0:        Cntus=0;
                                                        Cnt10ms=0;
                                                        Cnt1s=0;
                                                        Cnt1min=0;
                                                        Cnthour=0;        break;//清0
                                case 1:        suspend=1;  break;//计时
                                case 2:        suspend=0;        break;//暂停
                        }               
                }
        }
        else
        {
                count1=0;                                //计数变量清0
                key_sign=0;                                //按键状态标志清0
        }
}

/***********定时器初始化程序****************/
void Timer0Init()        //2500微秒@11.0592MHz
{
        TMOD = 0x01;        //设置定时器模式
        TL0 = 0x00;                //设置定时初值
        TH0 = 0xF7;                //设置定时初值
        TF0 = 0;                        //清除TF0标志
        TR0 = 1;                        //定时器0开始计时
        EA=1;                                //开总中断
        ET0=1;                        //开定时器0中断
}
void StopwatchDisplay()//数字分解
{
        LedBuff[0]=Cnthour/10;
        LedBuff[1]=Cnthour%10;
        LedBuff[2]=Cnt1min/10;
        LedBuff[3]=Cnt1min%10;
        LedBuff[4]=Cnt1s/10;
        LedBuff[5]=Cnt1s%10;
        LedBuff[6]=Cnt10ms/10;
        LedBuff[7]=Cnt10ms%10;
}

/***************主程序****************/
void main()
{
        Timer0Init();                                //定时器初始化
        while(1)
        {
                keyscan();                                //按键扫描
                StopwatchDisplay();
        }
}
/**************中断服务程序*****************/
void timer0() interrupt        1//2500微秒@11.0592MHz
{
        TL0 = 0x00;                                        //设置定时初值
        TH0 = 0xF7;                                        //设置定时初值
        Cntus++;                                                //中断变量Cntus自+1
        if(Cntus>=4)                                //10ms
        {
                Cntus=0;                                        //清0
                if(suspend==1)                        //暂停/启动
                        Cnt10ms++;                        //毫秒计数
                if(Cnt10ms>=100)
                {
                        Cnt10ms=0;
                        Cnt1s++;                                //秒计数
                        if(Cnt1s>=60)
                        {
                                Cnt1s=0;
                                Cnt1min++;                //分计数
                                if(Cnt1min>=60)
                                {
                                        Cnt1min=0;
                                        Cnthour++;        //时计数
                                        if(Cnthour>=24)
                                                Cnthour=0;
                                }
                        }
                }
        }
        LedScan();                                        //显示程序
}
void LedScan()//显示程序
{
        static u8 i=0;        //计数变量
        number=0x00;        //消隐
        wela=i<<2;                 //送位码
        if((i%2==1)&&(i!=7))//送段码
                number=smgduan[LedBuff]|0x80;//加点
        else         number=smgduan[LedBuff];
        if(++i>=8)
                i=0;
/*
        switch(i)
        {
                case 0: wela=i<<2; number=smgduan[LedBuff[0]];i++;break;
                case 1: wela=i<<2; number=smgduan[LedBuff[0]]|0x80;i++;break;
                case 2: wela=i<<2; number=smgduan[Cnt1min/10];it++;break;
                case 3: wela=i<<2; number=smgduan[Cnt1min%10]|0x80;i++;break;
                case 4: wela=i<<2; number=smgduan[Cnt1s/10];i++;break;                               
                case 5: wela=i<<2; number=smgduan[Cnt1s%10]|0x80;i++;break;                               
                case 6: wela=i<<2; number=smgduan[Cnt10ms/10];i++;break;       
                case 7: wela=i<<2; number=smgduan[Cnt10ms%10];i=0;break;       
        }*/
}
作者: 凛夏寒烟    时间: 2019-1-4 12:01
wulin 发表于 2019-1-4 11:21
给你改写成单键操作8位24小时百分秒表，有详细注释，应该能看得懂，经仿真无误。

#include

多谢多谢
作者: wulin    时间: 2019-1-4 13:16
凛夏寒烟 发表于 2019-1-4 12:01
多谢多谢

根据电路图J21跳线帽要接在VCC与LE，否则74HC573打不开，段码送不了。







欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1