分享自写码表单片机程序（共阴极数码管显示）

/*
晶振频率11.0592MHz

程序修改说明：
第一版程序在开发板上运行时，虽能基本完成功能，但闪烁严重，复位后数组还有异常数据等，应是算法问题，此版寻求解决之道。

问题之一：闪烁严重
将FormatTimeWithMS(TotalMS)语句从定时器中断程序中移出，放到mian中，问题得到解决，与预计的FormatTimeWithMS函数占了太大的时间资源不一致。
但发现出现另一问题：最后（右）一位显示明显偏亮，运行别的程序时，各位显示一致，但亮度与前面所述最后一位一致，说明其实是前7位亮度偏暗。
经调试，发现原因为消影语句放置位置不妥，修改位置后，闪烁问题完全解决。

问题之二：保存数据的数据重置后数据异常
经调试，发现原因为数组设置与读取不正确，修改后正常。
*/

1. #include <reg52.h>
   
2. #include <string.h>
   
3. 
   
4. typedef unsigned int u16;
   
5. typedef unsigned char u8;
   
6. 
   
7. sbit seg_sel = P2^6;
   
8. sbit bit_sel = P2^7;
   
9. sbit start_key = P3^0;
   
10. sbit record_key = P3^1;
    
11. sbit reload_key = P3^2;
    
12. sbit reset_key = P3^3;
    
13. 
    
14. //共阴极数码管0-9和"-"编码0x40
    
15. unsigned char code seg_table[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x7,0x7F,0x6F,0x40};
    
16. //数码管位码（数组第1位对应数码管最左位）
    
17. unsigned char code bit_table[]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F};
    
18. 
    
19. #define DATA P0
    
20. 
    
21. u8 timer;
    
22. //初始化显示数据
    
23. u8 TimeFormat[] = {0,0,1,0,0,1,0,0};
    
24. //数据记录数组，5组，每组8个数据
    
25. u8 ResultArray[5][8];
    
26. u8 ResultMax = 5;
    
27.         
    
28. u8 i,j,k,z;
    
29. unsigned long TotalMS;
    
30. u8 minS,minG,secS,secG,msS,msG;
    
31. bit IsReload;
    
32. 
    
33. void delay(u16 num)
    
34. {
    
35.         u16 m,n;
    
36.         for(m=num; m>0; m--)
    
37.                 for(n=113; n>0; n--);
    
38. }
    
39. 
    
40. //此函数将毫秒数转换成需要显示的时间格式（设置数组TimeFormat[]）
    
41. void FormatTimeWithMS(long tms)
    
42. {
    
43.         minS = (tms/60000)/10;
    
44.         minG = (tms/60000)%10;
    
45.         secS = (tms-(minS*10+minG)*60000)/1000/10;
    
46.         secG = (tms-(minS*10+minG)*60000)/1000%10;
    
47.         msS = (tms%1000)/100;
    
48.         msG = (tms%1000)%100/10;
    
49. 
    
50.         TimeFormat[0] = minS;
    
51.         TimeFormat[1] = minG;
    
52.         TimeFormat[3] = secS;
    
53.         TimeFormat[4] = secG;
    
54.         TimeFormat[6] = msS;
    
55.         TimeFormat[7] = msG;
    
56. }
    
57. 
    
58. void TimeDisplay(void)
    
59. {
    
60.         i = 0;
    
61.         for (j=0; j<8; j++)
    
62.         {
    
63.                 //移位
    
64.                 bit_sel = 1;
    
65.                 DATA = bit_table[j];
    
66.                 bit_sel = 0;
    
67. 
    
68.                 //显数
    
69.                 seg_sel = 1;
    
70.                 if ( i==2 | i==5 )
    
71.                 {
    
72.                         DATA = seg_table[10];
    
73.                 }else{
    
74.                         DATA = seg_table[TimeFormat[i]];
    
75.                         if (!IsReload)
    
76.                         {
    
77.                                 DATA = seg_table[TimeFormat[i]];
    
78.                         }else{
    
79.                                 DATA = seg_table[ResultArray[z][i]];
    
80.                         }
    
81.                 }
    
82.                 i++;
    
83.                 delay(1);
    
84.                
    
85.                 //消影
    
86.                 DATA = 0x00;
    
87.                 seg_sel = 0;
    
88.         }
    
89. }
    
90. 
    
91. void StopTimer(void)
    
92. {
    
93.         if(TR0){TR0=0;}        
    
94.         IsReload = 1;
    
95.         TotalMS = 0;
    
96.         FormatTimeWithMS(TotalMS);
    
97. }
    
98. 
    
99. void main(void)
    
100. {
     
101.         DATA = 0x00;
     
102.         P3 = 0xff;
     
103.         seg_sel = 0;
     
104.         bit_sel = 0;
     
105. 
     
106.         TMOD = 0x01;
     
107.         //单次溢出时间10ms之初值
     
108.         TH0 = 0xdc;
     
109.         TL0 = 0x00;
     
110.         EA = 1;
     
111.         ET0 = 1;
     
112. 
     
113.         TotalMS = 0;
     
114. 
     
115.         while(1)
     
116.         {
     
117.                 //计时启停
     
118.                 if (start_key == 0)
     
119.                 {
     
120.                         delay(10);
     
121.                         if (start_key == 0)
     
122.                         {
     
123.                                 TR0 = ~TR0;
     
124.                         }
     
125.                         while(!start_key);
     
126.                 }
     
127.                
     
128.                 //记录时间
     
129.                 if (record_key == 0)
     
130.                 {
     
131.                         delay(10);
     
132.                         if (record_key == 0)
     
133.                         {
     
134.                                 //小于最大记录时，记录数据；达到最大值时，停止计时器
     
135.                                 if (k < ResultMax)
     
136.                                 {
     
137.                                         ResultArray[k][0] = minS;
     
138.                                         ResultArray[k][1] = minG;
     
139.                                         ResultArray[k][2] = 1;
     
140.                                         ResultArray[k][3] = secS;
     
141.                                         ResultArray[k][4] = secG;
     
142.                                         ResultArray[k][5] = 1;
     
143.                                         ResultArray[k][6] = msS;
     
144.                                         ResultArray[k][7] = msG;
     
145.                                         k++;
     
146.                                         if (k==ResultMax) if(TR0){TR0=0;}
     
147.                                 }
     
148.                         }
     
149.                         while(!record_key);
     
150.                 }
     
151.                
     
152.                 //回显被记录的时间
     
153.                 if (reload_key == 0)
     
154.                 {
     
155.                         delay(10);
     
156.                         if (reload_key == 0)
     
157.                         {
     
158.                                 //如果不是回显数据，那么z=0（此处加判断的意义是首次点击回显键时，数据从第一组开始显示）
     
159.                                 if(!IsReload)
     
160.                                 {
     
161.                                         z = 0;
     
162.                                 }else{
     
163.                                         z++;
     
164.                                         if( z > (ResultMax-1)){z=0;}
     
165.                                 }
     
166.                                 StopTimer();
     
167.                         }
     
168.                         while(!reload_key);
     
169.                 }               
     
170.                
     
171.                 //重置（计时器停止，总显示时间清0，时间记录数组清0，回显数据状态置0）
     
172.                 if (reset_key == 0)
     
173.                 {
     
174.                         delay(10);
     
175.                         if (reset_key == 0)
     
176.                         {
     
177.                                 StopTimer();
     
178.                                 memset(ResultArray,0,sizeof(ResultArray));
     
179.                                 IsReload = 0;
     
180.                         }
     
181.                         while(!reset_key);
     
182.                 }
     
183. 
     
184.                 //显示时间
     
185.                 FormatTimeWithMS(TotalMS);
     
186.                 TimeDisplay();
     
187.         }
     
188. }
     
189. 
     
190. void timer0_service(void) interrupt 1
     
191. {
     
192.         TH0 = 0xdc;
     
193.         TL0 = 0x00;
     
194.         //因为是每10ms溢出一次，故总时间累加10ms。
     
195.         TotalMS = TotalMS+10;
     
196. }
     

复制代码

补全原理图或者详细说明一下电路连接即可获得100+黑币

admin 发表于 2018-10-10 19:21
补全原理图或者详细说明一下电路连接即可获得100+黑币

stopwatch.rar (20.15 KB, 下载次数: 10)

2018-11-20 15:35 上传

点击文件名下载附件
原理图和hex文件
谢谢管理！

stopwatch.rar (20.15 KB, 下载次数: 7)

2018-11-20 15:37 上传

点击文件名下载附件
附上原理图及hex文件，方便各位测试。