2个定时器计时并驱动扫描数码管(无软件延时)

admin

1. /*
   
2. 定时器驱动扫描数码管
   
3. T1扫描数码管
   
4. T0 负责计时
   
5. 全程未使用延时函数
   
6. */
   
7. #include <reg52.h>
   
8. 
   
9. #define Ulong unsigned long
   
10. #define Uint  unsigned int
    
11. #define Uchar unsigned char
    
12. 
    
13. sbit DU = P2 ^ 6; // 数码管段选
    
14. sbit WE = P2 ^ 7; // 位选
    
15. 
    
16. double code Crystal     = 11.0592; // 晶振频率 设定
    
17. double code Clock_Cycle = 12;      // 时钟周期
    
18. double Machine_Cycle;              // 机器周期
    
19. Ulong Need_time_US;                // 微秒总数量
    
20. 
    
21. Ulong Need_time_MS; // 计算溢出的毫秒
    
22. Ulong Need_time_S;  // 计算溢出的微秒
    
23. Ulong Need_time;    // 定时器0溢出的总数量计算
    
24. Ulong Need_time2;   // 定时器1溢出的总数量计算
    
25. Ulong display_count = 0, display_count1 = 0;
    
26. int val[8]; ///*存储每个位的数字数组变量*/
    
27. 
    
28. Uchar code DUtabel[] = {
    
29.     0x3F,
    
30.     0x06,
    
31.     0x5B,
    
32.     0x4F,
    
33.     0x66,
    
34.     0x6D,
    
35.     0x7D,
    
36.     0x07,
    
37.     0x7F,
    
38.     0x6F,
    
39.     0x77,
    
40.     0x7C,
    
41.     0x39,
    
42.     0x5E,
    
43.     0x79,
    
44.     0x71,
    
45.     0x76,
    
46.     0x38,
    
47.     0x40,
    
48.     0x00,
    
49. };
    
50. 
    
51. Uchar code WEtabel[] = {
    
52.     0x00, // 全亮,补位选空位
    
53.     0xFE,
    
54.     0xFD,
    
55.     0xfb,
    
56.     0xf7,
    
57.     0xef,
    
58.     0xdf,
    
59.     0xbf,
    
60.     0x7f,
    
61. };
    
62. 
    
63. void Sys_init();
    
64. void showval(Uchar val, Uchar WEval);
    
65. void display(int Z);
    
66. void T0_Timer_Init(Ulong U_time, int mod, int type);
    
67. void T1_Timer_Init(Ulong U_time, int mod, int type);
    
68. 
    
69. void delay(Uchar z, int mod);
    
70. 
    
71. ///////////////main/////////////////////
    
72. 
    
73. void main()
    
74. {
    
75. 
    
76.     Sys_init();             // 系统初始化
    
77.     T1_Timer_Init(5, 2, 0); // T1扫描数码管
    
78.     T0_Timer_Init(1, 3, 0); // T0 负责计时
    
79.     while (1) {
    
80.         // display(display_count);
    
81.     }
    
82. }
    
83. 
    
84. ////////////函数区域//////////////////
    
85. 
    
86. /*初始化参数*/
    
87. void Sys_init()
    
88. {
    
89.     Machine_Cycle = 1 / Crystal * Clock_Cycle; // 初始化 机器周期
    
90. }
    
91. 
    
92. void showval(Uchar val, Uchar WEval)
    
93. {
    
94. 
    
95.     WE = 1;              // 打开位选锁存
    
96.     P0 = WEtabel[WEval]; // 选择位选
    
97.     WE = 0;              // 位锁存
    
98. 
    
99.     DU = 1;            // 打开段选锁存器
    
100.     P0 = DUtabel[val]; // 送数据
     
101.     DU = 0;            // 段锁存
     
102. }
     
103. 
     
104. void display(int Z)
     
105. {
     
106. 
     
107.     static int i;
     
108.     if (i == Z) {
     
109.         i = 0;
     
110.         return;
     
111.     }
     
112. 
     
113.     P0 = 0XFF; // 清除段码
     
114.     showval(val[i], 8 - i);
     
115.     i++;
     
116. }
     
117. 
     
118. /*
     
119. 设置定时器
     
120. 参数1数量:   时间数量
     
121. 参数2单位: 1.微秒 2.毫秒 3.秒
     
122. 参数3模式: 0.定时器 1.计数器
     
123. #说明:引脚 计数器0引脚P3*4
     
124. */
     
125. void T0_Timer_Init(Ulong U_time, int mod, int type)
     
126. {
     
127. 
     
128.     if (type == 1) // 如果选择计数模式
     
129.     {
     
130.         TR0 = 1;
     
131.         TMOD |= 0X05;
     
132.         TH0 = 0;
     
133.         TL0 = 0;
     
134.     } else { // 如果为定时器模式
     
135. 
     
136.         /*时间转换*/
     
137.         if (mod == 3) {
     
138. 
     
139.             Need_time_US = U_time * 1000 * 1000;
     
140. 
     
141.         } else if (mod == 2) {
     
142. 
     
143.             Need_time_US = U_time * 1000;
     
144. 
     
145.         } else if (mod == 1) {
     
146. 
     
147.             Need_time_US = U_time;
     
148.         }
     
149.         /*设置定时器*/
     
150. 
     
151.         Need_time = (Ulong)(Need_time_US / Machine_Cycle) / 65535; // 获得溢出总量
     
152. 
     
153.         // 设置中断
     
154.         EA   = 1;    // 打开总中断
     
155.         ET0  = 1;    // 打开定时器0中断
     
156.         TR0  = 1;    // 启动定时器0
     
157.         TMOD = 0X01; // 定时器工作模式1，16位定时模式
     
158. 
     
159.         TH0 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) / 256; //(Need_time_US/Machine_Cycle)%65535 排除溢出位
     
160.         TL0 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) % 256;
     
161.     }
     
162. }
     
163. 
     
164. void T0_Time() interrupt 1
     
165. {
     
166.     static Ulong use_count;     // 已经执行的数量
     
167.     if (Need_time == use_count) // 判断Need_time总耗微秒数 是不是消耗完  如果消耗完 进入重置阶段
     
168.     {
     
169.         TH0 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) / 256; //(Need_time_US/Machine_Cycle)%65535 排除溢出位
     
170.         TL0 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) % 256;
     
171. 
     
172.         use_count = 0;   // 重置已消耗的数量
     
173.         display_count++; // 记录消耗完毕的次数
     
174.     } else {             // 如果没消耗完 继续进入下一轮定时中断触发消耗
     
175.         use_count++;     // 已消耗的数量加1
     
176.         TH0 = 0;         // 清0
     
177.         TL0 = 0;         // 清0
     
178.     }
     
179. }
     
180. 
     
181. /*
     
182. 设置定时器
     
183. 参数1数量:   时间数量
     
184. 参数2单位: 1.微秒 2.毫秒 3.秒
     
185. 参数3模式: 0.定时器 1.计数器
     
186. #说明:引脚 计数器1引脚P3*5
     
187. */
     
188. void T1_Timer_Init(Ulong U_time, int mod, int type)
     
189. {
     
190. 
     
191.     if (type == 1) // 如果选择计数模式
     
192.     {
     
193.         TR1 = 1;
     
194.         TMOD |= 0X50;
     
195.         TH1 = 0;
     
196.         TL1 = 0;
     
197.     } else { // 如果为定时器模式
     
198. 
     
199.         /*时间转换*/
     
200.         if (mod == 3) {
     
201. 
     
202.             Need_time_US = U_time * 1000 * 1000;
     
203. 
     
204.         } else if (mod == 2) {
     
205. 
     
206.             Need_time_US = U_time * 1000;
     
207. 
     
208.         } else if (mod == 1) {
     
209. 
     
210.             Need_time_US = U_time;
     
211.         }
     
212.         /*设置定时器*/
     
213. 
     
214.         Need_time2 = (Ulong)(Need_time_US / Machine_Cycle) / 65535; // 获得溢出总量
     
215. 
     
216.         // 设置中断
     
217.         EA   = 1;    // 打开总中断
     
218.         ET1  = 1;    // 打开定时器0中断
     
219.         TR1  = 1;    // 启动定时器0
     
220.         TMOD = 0X10; // 定时器工作模式1，16位定时模式
     
221. 
     
222.         TH1 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) / 256; //(Need_time_US/Machine_Cycle)%65535 排除溢出位
     
223.         TL1 = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) % 256;
     
224.     }
     
225. }
     
226. 
     
227. void T1_Time() interrupt 3
     
228. {
     
229.     Ulong use_count1; // 已经执行的数量
     
230.     int Zlen = 0;
     
231. 
     
232.     if (Need_time2 == use_count1) // 判断Need_time总耗微秒数 是不是消耗完  如果消耗完 进入重置阶段
     
233.     {
     
234.         TH1        = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) / 256; //(Need_time_US/Machine_Cycle)%65535 排除溢出位
     
235.         TL1        = (Ulong)(65535 - (Ulong)(Need_time_US / Machine_Cycle) % 65535) % 256;
     
236.         use_count1 = 0; // 重置已消耗的数量
     
237. 
     
238.         display_count1 = display_count;
     
239. 
     
240.         while (display_count1 != 0) {
     
241.             // 提取n的各个数位上的数
     
242.             val[Zlen++] = display_count1 % 10;
     
243.             display_count1 /= 10;
     
244.         }
     
245. 
     
246.         display(Zlen);
     
247. 
     
248.         //  display_count1++; // 记录消耗完毕的次数
     
249.     } else {          // 如果没消耗完 继续进入下一轮定时中断触发消耗
     
250.         use_count1++; // 已消耗的数量加1
     
251.         TH1 = 0;      // 清0
     
252.         TL1 = 0;      // 清0
     
253.     }
     
254. }
     
255. 
     
256. /*
     
257. 延迟函数.
     
258. 参数1:z为数量
     
259. 参数2:mod为模式
     
260. 1:毫秒
     
261. 2:秒
     
262. */
     
263. void delay(Uchar z, int mod)
     
264. {
     
265.     Ulong i;
     
266.     if (mod == 1) {
     
267.         for (i = 0; i < z; i++) {
     
268. 
     
269.             unsigned char a, b;
     
270.             for (b = 102; b > 0; b--)
     
271.                 for (a = 3; a > 0; a--)
     
272.                     ;
     
273.         }
     
274.     }
     
275. 
     
276.     else if (mod == 2) {
     
277.         for (i = 0; i < z * 1000; i++) {
     
278.             // 10000us //误差 -0.000000000002us
     
279.             unsigned char a, b;
     
280.             for (b = 102; b > 0; b--)
     
281.                 for (a = 3; a > 0; a--)
     
282.                     ;
     
283.         }
     
284.     }
     
285. }

复制代码