单片机——实现交通信号灯管理

随便写写，汇总一下，就一个单片机，没有模仿软件，什么都没有~
点阵、数码管、led同时点亮

1. #include <reg52.h>
3. sbit ADDR0 = P1^0;
4. sbit ADDR1 = P1^1;
5. sbit ADDR2 = P1^2;
6. sbit ADDR3 = P1^3;
7. sbit ENLED = P1^4;
9. // 交通灯控制引脚定义
10. sbit A_Red    = P0^0;
11. sbit A_Yellow = P0^1;
12. sbit A_Green  = P0^2;
13. sbit B_Red    = P0^3;
14. sbit B_Yellow = P0^4;
15. sbit B_Green  = P0^5;
17. unsigned char code LedChar[] = {  // 数码管显示字符转换表
18.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
19.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
20. };
21. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
22. unsigned char flag1s = 0;          // 1秒定时标志
24. // 交通灯状态变量
25. unsigned char current_state = 0;   // 0:A绿灯 1:A黄灯 2:B绿灯 3:B黄灯
26. unsigned char count_down = 27;     // 当前倒计时
27. bit yellow_blink = 0;              // 黄灯闪烁标志
28. unsigned int timer_count = 0;      // 定时器计数
30. // LED流水灯变量
31. static unsigned char j = 0;
32. static unsigned int shift1 = 0x01;
33. static unsigned int shift2 = 0x80;
34. static unsigned char dir1 = 0;
36. void main()
37. {
38.     EA = 1;                     // 开启总中断
39.     TMOD = 0x11;                // 使用定时器0和定时器1
41.     // 定时器0初始化（2ms，用于1秒定时）
42.     TH0 = 0xFC;
43.     TL0 = 0x67;
44.     ET0 = 1;
45.     TR0 = 1;
47.     // 定时器1初始化（1ms，用于数码管扫描）
48.     TH1 = 0xFC;
49.     TL1 = 0x67;
50.     ET1 = 1;
51.     TR1 = 1;
53.     // 初始状态：A绿灯，B红灯
54.     A_Green = 0;
55.     B_Red = 0;
56.     A_Red = B_Green = B_Yellow = A_Yellow = 1;
58.     while (1)
59.     {
60.         if (flag1s == 1)        // 每秒触发一次
61.         {
62.             flag1s = 0;
63.             
64.             // 交通灯状态机处理
65.             if(count_down > 0) count_down--;
66.             
67.             if(count_down == 0) {
68.                 switch(current_state) {
69.                     case 0: // A绿灯结束
70.                         current_state = 1;
71.                         count_down = 3;
72.                         A_Green = 1;
73.                         A_Yellow = 0;
74.                         break;
75.                         
76.                     case 1: // A黄灯结束
77.                         current_state = 2;
78.                         count_down = 17;
79.                         A_Yellow = 1;
80.                         B_Red = 1;
81.                         B_Green = 0;
82.                         break;
83.                         
84.                     case 2: // B绿灯结束
85.                         current_state = 3;
86.                         count_down = 3;
87.                         B_Green = 1;
88.                         B_Yellow = 0;
89.                         break;
90.                         
91.                     case 3: // B黄灯结束
92.                         current_state = 0;
93.                         count_down = 27;
94.                         B_Yellow = 1;
95.                         A_Red = 1;
96.                         A_Green = 0;
97.                         break;
98.                 }
99.             }
101.             // 更新数码管显示（显示倒计时）
102.             LedBuff[0] = LedChar[count_down % 10];  // 个位
103.             LedBuff[1] = LedChar[count_down / 10];   // 十位
104.             // 其余位保持熄灭
105.             LedBuff[2] = LedBuff[3] = LedBuff[4] = LedBuff[5] = 0xFF;
106.         }
107.     }
108. }
110. // 定时器1中断服务函数（1ms，用于数码管扫描和LED流水灯）
111. void Timer1_ISR() interrupt 3
112. {
113.     static unsigned char index = 0;
114.    
115.     TH1 = 0xFC;
116.     TL1 = 0x67;
117.    
118.     // 黄灯闪烁处理（500ms间隔）
119.     if(++timer_count % 250 == 0 &&
120.       (current_state == 1 || current_state == 3)) {
121.         yellow_blink = ~yellow_blink;
122.         if(current_state == 1) A_Yellow = yellow_blink;
123.         else B_Yellow = yellow_blink;
124.     }
126.     // 数码管动态扫描
127.     P0 = 0xFF;                  // 消隐
128.     ENLED = 0;
129.     ADDR3 = 1;                  // 选择数码管
130.    
131.     switch(index) {
132.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; P0=LedBuff[0]; break;
133.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; P0=LedBuff[1]; break;
134.         default: P0 = 0xFF;     // 其余位不显示
135.     }
136.    
137.     index = (index >= 1) ? 0 : index+1;
139.     // LED流水灯控制（复用case 6）
140.     if(index == 0) {  // 每轮扫描结束后处理LED
141.         ADDR3 = 1;    // 选择LED控制地址
142.         ADDR2 = 1;
143.         ADDR1 = 1;
144.         ADDR0 = 0;
145.         
146.         j++;
147.         if (j >= 200) {  // 每200ms改变一次LED位置
148.             j = 0;
149.             if (dir1 == 0) {  // 从左向右移动
150.                 shift1 <<= 1;
151.                 shift2 >>= 1;
152.                 if (shift1 == 0x80 && shift2 == 0x01)
153.                     dir1 = 1;  // 改变方向
154.             } else {  // 从右向左移动
155.                 shift1 >>= 1;
156.                 shift2 <<= 1;
157.                 if (shift1 == 0x01 && shift2 == 0x80)
158.                     dir1 = 0;  // 改变方向
159.             }
160.         }
161.         P0 = ~(shift1 | shift2);  // 输出LED状态
162.     }
163. }
165. // 定时器0中断服务函数（2ms，用于1秒定时）
166. void Timer0_ISR() interrupt 1
167. {
168.     static unsigned int sec_count = 0;
169.    
170.     TH0 = 0xFC;
171.     TL0 = 0x67;
172.    
173.     if(++sec_count >= 500) {  // 500 * 2ms = 1秒
174.         sec_count = 0;
175.         flag1s = 1;
176.     }
177. }

复制代码

红绿灯熄灭 

实现30秒绿灯倒计时熄灭，20秒倒计时红灯熄灭 

1. #include <reg52.h>
3. sbit ADDR0 = P1^0;
4. sbit ADDR1 = P1^1;
5. sbit ADDR2 = P1^2;
6. sbit ADDR3 = P1^3;
7. sbit ENLED = P1^4;
9. // 交通灯控制引脚定义
10. sbit A_Red    = P0^0;
11. sbit A_Yellow = P0^1;
12. sbit A_Green  = P0^2;
13. sbit B_Red    = P0^3;
14. sbit B_Yellow = P0^4;
15. sbit B_Green  = P0^5;
17. unsigned char code LedChar[] = {
18.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
19.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
20. };
21. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
23. volatile unsigned char flag1s = 0;
24. volatile unsigned int timer_count = 0;
25. unsigned char current_state = 0;  // 0:A绿灯 1:A黄灯 2:B绿灯 3:B黄灯
26. unsigned char count_down = 27;    // 当前倒计时
27. bit yellow_blink = 0;              // 黄灯闪烁标志
29. void main() {
30.     EA = 1;
31.     TMOD = 0x11;
32.    
33.     // 定时器0初始化（2ms）
34.     TH0 = 0xFC;
35.     TL0 = 0x67;
36.     ET0 = 1;
37.     TR0 = 1;
39.     // 定时器1初始化（1ms）
40.     TH1 = 0xFC;
41.     TL1 = 0x67;
42.     ET1 = 1;
43.     TR1 = 1;
45.     // 初始状态：A绿灯，B红灯
46.     A_Green = 0;
47.     B_Red = 0;
48.     A_Red = B_Green = B_Yellow = A_Yellow = 1;
50.     while(1) {
51.         if(flag1s) {
52.             flag1s = 0;
53.             
54.             // 状态机处理
55.             if(count_down > 0) count_down--;
56.             
57.             if(count_down == 0) {
58.                 switch(current_state) {
59.                     case 0: // A绿灯结束
60.                         current_state = 1;
61.                         count_down = 3;
62.                         A_Green = 1;
63.                         A_Yellow = 0;
64.                         break;
65.                         
66.                     case 1: // A黄灯结束
67.                         current_state = 2;
68.                         count_down = 17;
69.                         A_Yellow = 1;
70.                         B_Red = 1;
71.                         B_Green = 0;
72.                         break;
73.                         
74.                     case 2: // B绿灯结束
75.                         current_state = 3;
76.                         count_down = 3;
77.                         B_Green = 1;
78.                         B_Yellow = 0;
79.                         break;
80.                         
81.                     case 3: // B黄灯结束
82.                         current_state = 0;
83.                         count_down = 27;
84.                         B_Yellow = 1;
85.                         A_Red = 1;
86.                         A_Green = 0;
87.                         break;
88.                 }
89.             }
91.             // 更新数码管显示
92.             LedBuff[0] = LedChar[count_down % 10];  // 个位
93.             LedBuff[1] = LedChar[count_down / 10];   // 十位
94.         }
95.     }
96. }
98. // 定时器1中断（数码管扫描）
99. void Timer1_ISR() interrupt 3 {
100.     static unsigned char index = 0;
101.    
102.     TH1 = 0xFC;
103.     TL1 = 0x67;
104.    
105.     // 黄灯闪烁处理（500ms间隔）
106.     if(++timer_count % 250 == 0 &&
107.       (current_state == 1 || current_state == 3)) {
108.         yellow_blink = ~yellow_blink;
109.         if(current_state == 1) A_Yellow = yellow_blink;
110.         else B_Yellow = yellow_blink;
111.     }
113.     // 数码管动态扫描
114.     P0 = 0xFF;
115.     ENLED = 0;
116.     ADDR3 = 1;
117.    
118.     switch(index) {
119.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; P0=LedBuff[0]; break;
120.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; P0=LedBuff[1]; break;
121.         default: P0 = 0xFF;
122.     }
123.    
124.     index = (index >= 1) ? 0 : index+1;
125. }
127. // 定时器0中断（1秒定时）
128. void Timer0_ISR() interrupt 1 {
129.     static unsigned int sec_count = 0;
130.    
131.     TH0 = 0xFC;
132.     TL0 = 0x67;
133.    
134.     if(++sec_count >= 500) { // 500 * 2ms=1秒
135.         sec_count = 0;
136.         flag1s = 1;
137.     }
138. }

复制代码

红绿灯跳转

当绿灯30秒剩余三秒时跳转至黄灯，当黄灯3秒后 跳转红灯，红灯20秒后继承跳转

1. #include <reg52.h>
3. sbit ADDR0 = P1^0;
4. sbit ADDR1 = P1^1;
5. sbit ADDR2 = P1^2;
6. sbit ADDR3 = P1^3;
7. sbit ENLED = P1^4;
9. unsigned char code LedChar[] = {  // 数码管显示字符转换表
10.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
11.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
12. };
13. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
14. unsigned char flag1s = 0;
15. unsigned char countDownPhase = 0;  // 倒计时阶段：0=30->0, 1=20->0
16. unsigned long sec = 30;  // 初始值设为30
17. bit countDownFinished = 0;  // 倒计时结束标志
19. void main()
20. {
21.     char j;
22.     unsigned char buf[6];
24.     EA = 1;                     // 开启总中断
25.     TMOD = 0x01;                // 只使用定时器0
27.     // 定时器0初始化（T0）
28.     TH0 = 0xFC;                 // 定时1ms
29.     TL0 = 0x67;
30.     ET0 = 1;                    // 使能定时器0中断
31.     TR0 = 1;                    // 启动定时器0
33.     // 初始化显示30
34.     buf[0] = sec%10;            // 个位
35.     buf[1] = sec/10%10;         // 十位
36.     buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0; // 高位补0
37.    
38.     // 高位消零处理
39.     for (j=5; j>=1; j--)
40.     {
41.         if (buf[j] == 0)
42.             LedBuff[j] = 0xFF;  // 不显示前导零
43.         else
44.             break;
45.     }
46.     // 显示有效数字
47.     for (; j>=0; j--)
48.     {
49.         LedBuff[j] = LedChar[buf[j]];
50.     }
52.     while (1)
53.     {
54.         if (flag1s == 1)        // 每秒触发一次
55.         {
56.             flag1s = 0;
57.             
58.             if (!countDownFinished)  // 如果倒计时未结束
59.             {
60.                 if (sec > 0)
61.                 {
62.                     sec--;          // 秒计数器减1
63.                     
64.                     // 分解秒数为单个数字
65.                     buf[0] = sec%10;    // 个位
66.                     buf[1] = sec/10%10; // 十位
67.                     buf[2] = sec/100%10;
68.                     buf[3] = sec/1000%10;
69.                     buf[4] = sec/10000%10;
70.                     buf[5] = sec/100000%10;
72.                     // 高位消零处理
73.                     for (j=5; j>=1; j--)
74.                     {
75.                         if (buf[j] == 0)
76.                             LedBuff[j] = 0xFF;  // 不显示前导零
77.                         else
78.                             break;
79.                     }
80.                     // 显示有效数字
81.                     for (; j>=0; j--)
82.                     {
83.                         LedBuff[j] = LedChar[buf[j]];
84.                     }
85.                 }
86.                 else
87.                 {
88.                     countDownFinished = 1;  // 倒计时结束
89.                     
90.                     // 切换到下一阶段
91.                     countDownPhase++;
92.                     if (countDownPhase == 1) {
93.                         // 进入20->0阶段
94.                         sec = 20;
95.                         countDownFinished = 0;  // 重置结束标志
96.                         
97.                         // 更新显示
98.                         buf[0] = sec%10;
99.                         buf[1] = sec/10%10;
100.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
101.                         
102.                         for (j=5; j>=1; j--)
103.                         {
104.                             if (buf[j] == 0)
105.                                 LedBuff[j] = 0xFF;
106.                             else
107.                                 break;
108.                         }
109.                         for (; j>=0; j--)
110.                         {
111.                             LedBuff[j] = LedChar[buf[j]];
112.                         }
113.                     }
114.                     else if (countDownPhase >= 2) {
115.                         // 所有阶段完成，重置到第一阶段
116.                         countDownPhase = 0;
117.                         sec = 30;
118.                         countDownFinished = 0;
119.                         
120.                         // 更新显示
121.                         buf[0] = sec%10;
122.                         buf[1] = sec/10%10;
123.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
124.                         
125.                         for (j=5; j>=1; j--)
126.                         {
127.                             if (buf[j] == 0)
128.                                 LedBuff[j] = 0xFF;
129.                             else
130.                                 break;
131.                         }
132.                         for (; j>=0; j--)
133.                         {
134.                             LedBuff[j] = LedChar[buf[j]];
135.                         }
136.                     }
137.                 }
138.             }
139.         }
140.     }
141. }
143. // 定时器0中断服务函数（修改LED控制部分）
144. void Timer0_ISR() interrupt 1
145. {
146.     static unsigned char j = 0;
147.     static unsigned char i = 0;
148.     static unsigned int cnt = 0;
149.     static unsigned int shift1 = 0x01;
150.     static unsigned int shift2 = 0x80;
151.     static unsigned char dir1 = 0;
153.     TH0 = 0xFC;                 // 重新加载初值
154.     TL0 = 0x67;
155.    
156.     P0 = 0xFF;                  // 显示消隐
157.     ENLED = 0;                  // 使能显示
158.     ADDR3 = 1;                  // 选择数码管和LED
160.     // 数码管动态扫描（保持不变）
161.     switch (i)
162.     {
163.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
164.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
165.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
166.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
167.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
168.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=LedBuff[5]; break;
169.         case 6: // LED控制（修改部分）
170.             ADDR2=1; ADDR1=1; ADDR0=0;
171.             
172.             // 根据倒计时阶段控制LED
173.             if (countDownPhase == 0) {
174.                 // 30秒倒计时阶段，点亮第一个LED（P0.0）
175.                 P0 = 0xFE;  // 二进制 1111 1110，仅P0.0为低电平
176.             } else {
177.                 // 20秒倒计时阶段，熄灭所有LED
178.                 P0 = 0xFF;  // 二进制 1111 1111，所有LED熄灭
179.             }
180.             
181.             i = 0;
182.             break;
183.         default: break;
184.     }
186.     // 1秒定时处理（保持不变）
187.     cnt++;
188.     if (cnt >= 1000)            // 1000ms = 1s
189.     {
190.         cnt = 0;
191.         flag1s = 1;             // 设置1秒标志
192.     }
193. }

复制代码

增加B车道 

30秒阶段LED 逻辑:

30 秒→4 秒：点亮 LED2和 LED7
3 秒→0 秒：点亮 LED3和 LED

20 秒阶段 LED 逻辑：
20 秒→4 秒：点亮 LED4和 LED5
3 秒→0 秒：点亮 LED4和 LED6

1. #include <reg52.h>
3. sbit ADDR0 = P1^0;
4. sbit ADDR1 = P1^1;
5. sbit ADDR2 = P1^2;
6. sbit ADDR3 = P1^3;
7. sbit ENLED = P1^4;
9. unsigned char code LedChar[] = {  // 数码管显示字符转换表
10.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
11.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
12. };
13. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
14. unsigned char flag1s = 0;
15. unsigned char countDownPhase = 0;  // 倒计时阶段：0=30秒阶段, 1=20秒阶段
16. unsigned long sec = 30;  // 初始值设为30
17. bit countDownFinished = 0;  // 倒计时结束标志
19. void main()
20. {
21.     char j;
22.     unsigned char buf[6];
24.     EA = 1;                     // 开启总中断
25.     TMOD = 0x01;                // 只使用定时器0
27.     // 定时器0初始化（T0）
28.     TH0 = 0xFC;                 // 定时1ms
29.     TL0 = 0x67;
30.     ET0 = 1;                    // 使能定时器0中断
31.     TR0 = 1;                    // 启动定时器0
33.     // 初始化显示30
34.     buf[0] = sec%10;            // 个位
35.     buf[1] = sec/10%10;         // 十位
36.     buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0; // 高位补0
37.    
38.     // 高位消零处理
39.     for (j=5; j>=1; j--)
40.     {
41.         if (buf[j] == 0)
42.             LedBuff[j] = 0xFF;  // 不显示前导零
43.         else
44.             break;
45.     }
46.     // 显示有效数字
47.     for (; j>=0; j--)
48.     {
49.         LedBuff[j] = LedChar[buf[j]];
50.     }
52.     while (1)
53.     {
54.         if (flag1s == 1)        // 每秒触发一次
55.         {
56.             flag1s = 0;
57.             
58.             if (!countDownFinished)  // 如果倒计时未结束
59.             {
60.                 if (sec > 0)
61.                 {
62.                     sec--;          // 秒计数器减1
63.                     
64.                     // 分解秒数为单个数字
65.                     buf[0] = sec%10;    // 个位
66.                     buf[1] = sec/10%10; // 十位
67.                     buf[2] = sec/100%10;
68.                     buf[3] = sec/1000%10;
69.                     buf[4] = sec/10000%10;
70.                     buf[5] = sec/100000%10;
72.                     // 高位消零处理
73.                     for (j=5; j>=1; j--)
74.                     {
75.                         if (buf[j] == 0)
76.                             LedBuff[j] = 0xFF;  // 不显示前导零
77.                         else
78.                             break;
79.                     }
80.                     // 显示有效数字
81.                     for (; j>=0; j--)
82.                     {
83.                         LedBuff[j] = LedChar[buf[j]];
84.                     }
85.                 }
86.                 else
87.                 {
88.                     countDownFinished = 1;  // 倒计时结束
89.                     
90.                     // 切换到下一阶段
91.                     countDownPhase++;
92.                     if (countDownPhase == 1) {
93.                         // 进入20->0阶段
94.                         sec = 20;
95.                         countDownFinished = 0;  // 重置结束标志
96.                         
97.                         // 更新显示
98.                         buf[0] = sec%10;
99.                         buf[1] = sec/10%10;
100.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
101.                         
102.                         for (j=5; j>=1; j--)
103.                         {
104.                             if (buf[j] == 0)
105.                                 LedBuff[j] = 0xFF;
106.                             else
107.                                 break;
108.                         }
109.                         for (; j>=0; j--)
110.                         {
111.                             LedBuff[j] = LedChar[buf[j]];
112.                         }
113.                     }
114.                     else if (countDownPhase >= 2) {
115.                         // 所有阶段完成，重置到第一阶段
116.                         countDownPhase = 0;
117.                         sec = 30;
118.                         countDownFinished = 0;
119.                         
120.                         // 更新显示
121.                         buf[0] = sec%10;
122.                         buf[1] = sec/10%10;
123.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
124.                         
125.                         for (j=5; j>=1; j--)
126.                         {
127.                             if (buf[j] == 0)
128.                                 LedBuff[j] = 0xFF;
129.                             else
130.                                 break;
131.                         }
132.                         for (; j>=0; j--)
133.                         {
134.                             LedBuff[j] = LedChar[buf[j]];
135.                         }
136.                     }
137.                 }
138.             }
139.         }
140.     }
141. }
143. // 定时器0中断服务函数（修改LED控制部分）
144. void Timer0_ISR() interrupt 1
145. {
146.     static unsigned char j = 0;
147.     static unsigned char i = 0;
148.     static unsigned int cnt = 0;
150.     TH0 = 0xFC;                 // 重新加载初值
151.     TL0 = 0x67;
152.    
153.     P0 = 0xFF;                  // 显示消隐
154.     ENLED = 0;                  // 使能显示
155.     ADDR3 = 1;                  // 选择数码管和LED
157.     // 数码管动态扫描
158.     switch (i)
159.     {
160.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
161.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
162.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
163.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
164.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
165.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=LedBuff[5]; break;
166.         case 6: // LED控制部分
167.             ADDR2=1; ADDR1=1; ADDR0=0;
168.             
169.             // 根据倒计时阶段和剩余秒数控制LED
170.             if (countDownPhase == 0) {
171.                 // 30秒倒计时阶段
172.                 if (sec > 3) {
173.                     // 前27秒：LED1(P0.0)和LED6(P0.5)亮
174.                     P0 = 0xDE;  // 二进制 1101 1110 (P0.0和P0.5低电平)
175.                 } else if (sec > 0) {
176.                     // 后3秒：LED2(P0.1)和LED6(P0.5)亮
177.                     P0 = 0xDD;  // 二进制 1101 1101 (P0.1和P0.5低电平)
178.                 } else {
179.                     // 倒计时结束：熄灭所有LED
180.                     P0 = 0xFF;
181.                 }
182.             } else if (countDownPhase == 1) {
183.                 // 20秒倒计时阶段
184.                 if (sec > 3) {
185.                     // 前17秒：LED3(P0.2)和LED4(P0.3)亮
186.                     P0 = 0xF3;  // 二进制 1111 0011 (P0.2和P0.3低电平)
187.                 } else if (sec > 0) {
188.                     // 后3秒：LED3(P0.2)和LED5(P0.4)亮
189.                     P0 = 0xEB;  // 二进制 1110 1011 (P0.2和P0.4低电平)
190.                 } else {
191.                     // 倒计时结束：熄灭所有LED
192.                     P0 = 0xFF;
193.                 }
194.             } else {
195.                 // 其他阶段：熄灭所有LED
196.                 P0 = 0xFF;
197.             }
198.             
199.             i = 0;
200.             break;
201.         default: break;
202.     }
204.     // 1秒定时处理
205.     cnt++;
206.     if (cnt >= 1000)            // 1000ms = 1s
207.     {
208.         cnt = 0;
209.         flag1s = 1;             // 设置1秒标志
210.     }
211. }

复制代码

按键控制led灯的10秒定时亮灭

1. #include <reg52.h>
3. // 引脚定义（补充完整矩阵按键输出和输入引脚）
4. sbit ADDR0 = P1^0;
5. sbit ADDR1 = P1^1;
6. sbit ADDR2 = P1^2;
7. sbit ADDR3 = P1^3;
8. sbit ENLED = P1^4;
9. sbit KEY_OUT_1 = P2^3;  // 矩阵按键输出引脚（完整定义）
10. sbit KEY_OUT_2 = P2^2;
11. sbit KEY_OUT_3 = P1^2;  // 假设KEY_OUT_3连接到P1^2（避免与ADDR2冲突）
12. sbit KEY_OUT_4 = P1^3;  // 假设KEY_OUT_4连接到P1^3（避免与ADDR3冲突）
13. sbit KEY_IN_1  = P2^4;  // 矩阵按键输入引脚（完整定义）
14. sbit KEY_IN_2  = P2^5;
15. sbit KEY_IN_3  = P2^6;
16. sbit KEY_IN_4  = P2^7;
17. sbit LED1 = P0^0;      // K2控制的LED（原LED）
18. sbit LED4 = P0^3;      // K1控制的LED4（假设连接到P0^3）
20. // 状态变量
21. unsigned char KeySta[4][4] = {  // 按键状态数组（使用[0][0]对应K1，[0][1]对应K2）
22.     {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
23. };
24. unsigned int Timer10s_LED1 = 0;  // LED1的10秒计时计数器
25. unsigned int Timer10s_LED4 = 0;  // LED4的10秒计时计数器
26. bit Led1Active = 0;             // LED1激活标志
27. bit Led4Active = 0;             // LED4激活标志
29. // 定时器0参数（1ms定时）
30. #define TIMER0_RELOAD_H 0xFC  // 1ms初值高位
31. #define TIMER0_RELOAD_L 0x67  // 1ms初值低位
33. void main()
34. {
35.     // 硬件初始化
36.     ENLED = 0;                // 使能LED控制
37.     ADDR3 = 1;                // 选择LED所在电路（共阳连接）
38.     ADDR2 = 1;
39.     ADDR1 = 1;
40.     ADDR0 = 0;
41.     LED1 = 1;                 // 初始熄灭LED1
42.     LED4 = 1;                 // 初始熄灭LED4
44.     // 定时器0初始化
45.     TMOD = 0x01;              // 模式1（16位定时器）
46.     TH0 = TIMER0_RELOAD_H;
47.     TL0 = TIMER0_RELOAD_L;
48.     ET0 = 1;                  // 使能定时器中断
49.     EA = 1;                   // 使能总中断
50.     TR0 = 1;                  // 启动定时器
52.     // 矩阵按键初始化
53.     KEY_OUT_1 = 1;            // 初始拉高所有行
54.     KEY_OUT_2 = 1;
55.     KEY_OUT_3 = 1;
56.     KEY_OUT_4 = 1;
58.     while (1)
59.     {
60.         // 检测K1按键状态（矩阵坐标[0][0]，第1行第1列）
61.         if (KeySta[0][0] == 0 && !Led4Active)  // K1按下且LED4未激活
62.         {
63.             LED4 = 0;                 // 点亮LED4
64.             Led4Active = 1;           // 标记LED4激活
65.             Timer10s_LED4 = 0;        // 重置LED4计时器
66.             while (KeySta[0][0] == 0);  // 等待K1释放
67.         }
69.         // 检测K2按键状态（矩阵坐标[0][1]，第1行第2列）
70.         if (KeySta[0][1] == 0 && !Led1Active)  // K2按下且LED1未激活
71.         {
72.             LED1 = 0;                 // 点亮LED1
73.             Led1Active = 1;           // 标记LED1激活
74.             Timer10s_LED1 = 0;        // 重置LED1计时器
75.             while (KeySta[0][1] == 0);  // 等待K2释放
76.         }
77.     }
78. }
80. /* 定时器0中断服务函数（1ms执行一次） */
81. void InterruptTimer0() interrupt 1
82. {
83.     static unsigned char keyout = 0;       // 矩阵行扫描索引
84.     static unsigned char keybuf[4][4] = {  // 按键消抖缓冲区
85.         {0xFF, 0xFF, 0xFF, 0xFF},
86.         {0xFF, 0xFF, 0xFF, 0xFF},
87.         {0xFF, 0xFF, 0xFF, 0xFF},
88.         {0xFF, 0xFF, 0xFF, 0xFF}
89.     };
91.     // 重新加载定时器初值
92.     TH0 = TIMER0_RELOAD_H;
93.     TL0 = TIMER0_RELOAD_L;
95.     // 扫描第1行（KEY_OUT_1）
96.     KEY_OUT_1 = 0;          // 拉低第1行
97.     KEY_OUT_2 = 1;          // 拉高其他行
98.     KEY_OUT_3 = 1;
99.     KEY_OUT_4 = 1;
101.     // 读取K1和K2的按键值（第1行第1、2列）
102.     keybuf[0][0] = (keybuf[0][0] << 1) | KEY_IN_1;  // K1（第1列）
103.     keybuf[0][1] = (keybuf[0][1] << 1) | KEY_IN_2;  // K2（第2列）
105.     // K1消抖逻辑
106.     if ((keybuf[0][0] & 0x0F) == 0x00)  
107.     {
108.         KeySta[0][0] = 0;  // 标记K1按下
109.     }
110.     else if ((keybuf[0][0] & 0x0F) == 0x0F)
111.     {
112.         KeySta[0][0] = 1;  // 标记K1释放
113.     }
115.     // K2消抖逻辑
116.     if ((keybuf[0][1] & 0x0F) == 0x00)  
117.     {
118.         KeySta[0][1] = 0;  // 标记K2按下
119.     }
120.     else if ((keybuf[0][1] & 0x0F) == 0x0F)
121.     {
122.         KeySta[0][1] = 1;  // 标记K2释放
123.     }
125.     // LED1计时逻辑
126.     if (Led1Active)
127.     {
128.         Timer10s_LED1++;
129.         if (Timer10s_LED1 >= 10000)  
130.         {
131.             LED1 = 1;
132.             Led1Active = 0;
133.         }
134.     }
136.     // LED4计时逻辑
137.     if (Led4Active)
138.     {
139.         Timer10s_LED4++;
140.         if (Timer10s_LED4 >= 10000)  
141.         {
142.             LED4 = 1;
143.             Led4Active = 0;
144.         }
145.     }
146. }

复制代码

按下按键暂停红绿灯时间

1. #include <reg52.h>
3. // 引脚定义
4. sbit ADDR0 = P1^0;
5. sbit ADDR1 = P1^1;
6. sbit ADDR2 = P1^2;
7. sbit ADDR3 = P1^3;
8. sbit ENLED = P1^4;
9. sbit KEY_OUT_1 = P2^3;
10. sbit KEY_OUT_2 = P2^2;
11. sbit KEY_OUT_3 = P1^2;
12. sbit KEY_OUT_4 = P1^3;
13. sbit KEY_IN_1  = P2^4;  // K1按键输入
14. sbit KEY_IN_2  = P2^5;  // K2按键输入
16. // 数码管显示
17. unsigned char code LedChar[] = {
18.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
19.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
20. };
21. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
23. // 状态变量
24. unsigned char flag1s = 0;
25. unsigned char flag10ms = 0;
26. unsigned char countDownPhase = 0;  // 0=30秒阶段, 1=20秒阶段
27. unsigned long sec = 30;
28. bit countDownFinished = 0;
30. // 按键状态和LED控制
31. unsigned char KeySta[4][4] = {
32.     {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
33. };
34. bit K1_Pressed = 0;  // K1按键按下标志
35. bit K2_Pressed = 0;  // K2按键按下标志
36. bit LED_SpecialMode = 0; // 特殊LED模式标志
37. unsigned int SpecialModeTimer = 0; // 特殊模式计时器(10秒)
38. unsigned int secCnt = 0; // 秒计数器
39. bit SpecialModeType = 0; // 0=K1模式, 1=K2模式
41. void main()
42. {
43.     char j;
44.     unsigned char buf[6];
46.     // 初始化
47.     EA = 1;
48.     TMOD = 0x01;
49.     TH0 = 0xFC;
50.     TL0 = 0x67;
51.     ET0 = 1;
52.     TR0 = 1;
53.    
54.     // 初始化显示30
55.     buf[0] = sec%10;
56.     buf[1] = sec/10%10;
57.     buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
58.    
59.     for (j=5; j>=1; j--)
60.     {
61.         if (buf[j] == 0)
62.             LedBuff[j] = 0xFF;
63.         else
64.             break;
65.     }
66.     for (; j>=0; j--)
67.     {
68.         LedBuff[j] = LedChar[buf[j]];
69.     }
71.     while (1)
72.     {
73.         // 检测K1按键状态(30秒阶段)
74.         if (countDownPhase == 0 && KeySta[0][0] == 0 && !K1_Pressed && sec > 3)
75.         {
76.             K1_Pressed = 1;
77.             LED_SpecialMode = 1;
78.             SpecialModeTimer = 0;
79.             SpecialModeType = 0; // K1模式
80.             while (KeySta[0][0] == 0);  // 等待释放
81.         }
82.         else if (KeySta[0][0] == 1)
83.         {
84.             K1_Pressed = 0;
85.         }
87.         // 检测K2按键状态(20秒阶段)
88.         if (countDownPhase == 1 && KeySta[0][1] == 0 && !K2_Pressed && sec > 3)
89.         {
90.             K2_Pressed = 1;
91.             LED_SpecialMode = 1;
92.             SpecialModeTimer = 0;
93.             SpecialModeType = 1; // K2模式
94.             while (KeySta[0][1] == 0);  // 等待释放
95.         }
96.         else if (KeySta[0][1] == 1)
97.         {
98.             K2_Pressed = 0;
99.         }
101.         // 特殊模式计时
102.         if (flag10ms && LED_SpecialMode) {
103.             SpecialModeTimer++;
104.             if (SpecialModeTimer >= 1000) { // 1000*10ms = 10秒
105.                 LED_SpecialMode = 0;
106.             }
107.         }
109.         // 倒计时处理
110.         if (flag1s == 1)
111.         {
112.             flag1s = 0;
113.             
114.             if (!countDownFinished)
115.             {
116.                 if (sec > 0)
117.                 {
118.                     sec--;
119.                     
120.                     buf[0] = sec%10;
121.                     buf[1] = sec/10%10;
122.                     buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
124.                     for (j=5; j>=1; j--)
125.                     {
126.                         if (buf[j] == 0)
127.                             LedBuff[j] = 0xFF;
128.                         else
129.                             break;
130.                     }
131.                     for (; j>=0; j--)
132.                     {
133.                         LedBuff[j] = LedChar[buf[j]];
134.                     }
135.                 }
136.                 else
137.                 {
138.                     countDownFinished = 1;
139.                     countDownPhase++;
140.                     LED_SpecialMode = 0; // 阶段切换时重置特殊模式
141.                     
142.                     if (countDownPhase == 1) {
143.                         sec = 20;
144.                         countDownFinished = 0;
145.                         
146.                         buf[0] = sec%10;
147.                         buf[1] = sec/10%10;
148.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
149.                         
150.                         for (j=5; j>=1; j--)
151.                         {
152.                             if (buf[j] == 0)
153.                                 LedBuff[j] = 0xFF;
154.                             else
155.                                 break;
156.                         }
157.                         for (; j>=0; j--)
158.                         {
159.                             LedBuff[j] = LedChar[buf[j]];
160.                         }
161.                     }
162.                     else if (countDownPhase >= 2) {
163.                         countDownPhase = 0;
164.                         sec = 30;
165.                         countDownFinished = 0;
166.                         
167.                         buf[0] = sec%10;
168.                         buf[1] = sec/10%10;
169.                         buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
170.                         
171.                         for (j=5; j>=1; j--)
172.                         {
173.                             if (buf[j] == 0)
174.                                 LedBuff[j] = 0xFF;
175.                             else
176.                                 break;
177.                         }
178.                         for (; j>=0; j--)
179.                         {
180.                             LedBuff[j] = LedChar[buf[j]];
181.                         }
182.                     }
183.                 }
184.             }
185.         }
186.     }
187. }
189. // 定时器0中断服务函数
190. void Timer0_ISR() interrupt 1
191. {
192.     static unsigned char i = 0;
193.     static unsigned int cnt = 0;
194.     static unsigned char keyout = 0;
195.     static unsigned char keybuf[4][4] = {
196.         {0xFF, 0xFF, 0xFF, 0xFF},
197.         {0xFF, 0xFF, 0xFF, 0xFF},
198.         {0xFF, 0xFF, 0xFF, 0xFF},
199.         {0xFF, 0xFF, 0xFF, 0xFF}
200.     };
202.     TH0 = 0xFC;
203.     TL0 = 0x67;
204.    
205.     // 按键扫描(仅扫描第1行)
206.     KEY_OUT_1 = 0;
207.     KEY_OUT_2 = 1;
208.     KEY_OUT_3 = 1;
209.     KEY_OUT_4 = 1;
211.     keybuf[0][0] = (keybuf[0][0] << 1) | KEY_IN_1;  // K1
212.     keybuf[0][1] = (keybuf[0][1] << 1) | KEY_IN_2;  // K2
214.     // K1消抖
215.     if ((keybuf[0][0] & 0x0F) == 0x00)
216.         KeySta[0][0] = 0;
217.     else if ((keybuf[0][0] & 0x0F) == 0x0F)
218.         KeySta[0][0] = 1;
220.     // K2消抖
221.     if ((keybuf[0][1] & 0x0F) == 0x00)
222.         KeySta[0][1] = 0;
223.     else if ((keybuf[0][1] & 0x0F) == 0x0F)
224.         KeySta[0][1] = 1;
226.     // 数码管显示和LED控制
227.     P0 = 0xFF;
228.     ENLED = 0;
229.     ADDR3 = 1;
231.     switch (i)
232.     {
233.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
234.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
235.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
236.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
237.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
238.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=LedBuff[5]; break;
239.         case 6:
240.             ADDR2=1; ADDR1=1; ADDR0=0;
241.             
242.             if (countDownPhase == 0) {
243.                 // 30秒阶段
244.                 if (sec > 3) {
245.                     // 前27秒
246.                     if (LED_SpecialMode && !SpecialModeType) {
247.                         P0 = 0xD7;  // LED1(P0.0)和LED4(P0.3)亮 (11010111)
248.                     } else {
249.                         P0 = 0xDE;  // 默认:LED1(P0.0)和LED6(P0.5)亮 (11011110)
250.                     }
251.                 } else if (sec > 0) {
252.                     // 后3秒
253.                     P0 = 0xDD;  // LED2(P0.1)和LED6(P0.5)亮 (11011101)
254.                 } else {
255.                     P0 = 0xFF;  // 熄灭所有
256.                 }
257.             } else if (countDownPhase == 1) {
258.                 // 20秒阶段
259.                 if (sec > 3) {
260.                     // 前17秒
261.                     if (LED_SpecialMode && SpecialModeType) {
262.                         P0 = 0xF6;  // LED1(P0.0)和LED4(P0.3)亮 (11110110)
263.                     } else {
264.                         P0 = 0xF3;  // 默认:LED3(P0.2)和LED4(P0.3)亮 (11110011)
265.                     }
266.                 } else if (sec > 0) {
267.                     // 后3秒
268.                     P0 = 0xEB;  // LED3(P0.2)和LED5(P0.4)亮 (11101011)
269.                 } else {
270.                     P0 = 0xFF;  // 熄灭所有
271.                 }
272.             } else {
273.                 P0 = 0xFF;
274.             }
275.             
276.             i = 0;
277.             break;
278.         default: break;
279.     }
281.     // 定时处理
282.     cnt++;
283.     if (cnt >= 10) {  // 10ms
284.         cnt = 0;
285.         flag10ms = 1;
286.         
287.         secCnt++;
288.         if (secCnt >= 100) {  // 100*10ms = 1s
289.             secCnt = 0;
290.             flag1s = 1;
291.         }
292.     } else {
293.         flag10ms = 0;
294.     }
295. }

复制代码

基于STC89C52单片机的交通灯控制系统设计
用单片机控制一个交通信号灯系统，设 A 车道与 B 车道交织构成十字路口， A 是主车道， B 是支车道。具体要求如下：(1)用发光二极管模仿交通信号灯， A 、 B 车道各三盏灯，分别代表红、黄、绿；用
按键开关模仿车辆检测信号。(2)
正常情况下， A 、 B 辆车道轮替放行， A 车道放行30s，此中3s用于警告； B 车道放行20s，此中3s用于警告。
(3)
在交通繁忙时，交通信号灯控制系统应有手控开关，可人为地改变信号灯的状态，以缓解交通拥挤状况。在 B 车道放行期间，若 A 车道有车而 B 车道无车，按下开关K1使 A 车道放行10s；在 A 车道放行期间，若 B 车道有车而 A 车道无车，按下开关K2使 B 车道放行10s。(4）有紧急车辆通过时，按下K3开关使 A 、 B 车道均为红灯，禁行15s。

 

1. #include <reg52.h>
3. sbit ADDR0 = P1^0;
4. sbit ADDR1 = P1^1;
5. sbit ADDR2 = P1^2;
6. sbit ADDR3 = P1^3;
7. sbit ENLED = P1^4;
9. // 矩阵按键引脚定义
10. sbit KEY_IN_1 = P2^4;  // 第1列
11. sbit KEY_IN_2 = P2^5;  // 第2列
12. sbit KEY_IN_3 = P2^6;  // 第3列
13. sbit KEY_IN_4 = P2^7;  // 第4列
14. sbit KEY_OUT_1 = P2^3; // 第1行
15. sbit KEY_OUT_2 = P2^2; // 第2行
16. sbit KEY_OUT_3 = P2^1; // 第3行
17. sbit KEY_OUT_4 = P2^0; // 第4行
19. unsigned char code LedChar[] = {
20.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
21.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
22. };
23. unsigned char LedBuff[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
24. unsigned char flag1s = 0;
25. unsigned char countDownPhase = 0;  // 0=30秒阶段, 1=20秒阶段
26. unsigned long sec = 30;
27. bit countDownFinished = 0;
29. // 按键和LED控制变量
30. bit K1_pressed = 0;          // K1按下标志(第1行第1列)
31. bit K2_pressed = 0;          // K2按下标志(第1行第2列)
32. unsigned char K1_holdTime = 0; // K1按下保持时间
33. unsigned char K2_holdTime = 0; // K2按下保持时间
34. bit LED_override = 0;        // LED覆盖标志
35. unsigned char overrideLEDState = 0xFF; // 覆盖的LED状态
36. unsigned char normalLEDState = 0xFF; // 正常LED状态
38. void KeyScan();
39. void UpdateLEDs();
41. void main()
42. {
43.     char j;
44.     unsigned char buf[6];
46.     EA = 1;
47.     TMOD = 0x01;
48.     TH0 = 0xFC;
49.     TL0 = 0x67;
50.     ET0 = 1;
51.     TR0 = 1;
53.     // 初始化显示30
54.     buf[0] = sec%10;
55.     buf[1] = sec/10%10;
56.     buf[2] = 0; buf[3] = 0; buf[4] = 0; buf[5] = 0;
57.    
58.     for (j=5; j>=1; j--) {
59.         if (buf[j] == 0) LedBuff[j] = 0xFF;
60.         else break;
61.     }
62.     for (; j>=0; j--) {
63.         LedBuff[j] = LedChar[buf[j]];
64.     }
66.     while(1) {
67.         KeyScan();
68.         
69.         if (flag1s == 1) {
70.             flag1s = 0;
71.             
72.             // 处理K1按下后的10秒计时
73.             if (K1_pressed) {
74.                 K1_holdTime++;
75.                 if (K1_holdTime >= 10) {
76.                     K1_pressed = 0;
77.                     K1_holdTime = 0;
78.                     LED_override = 0; // 恢复正常LED状态
79.                 }
80.             }
81.             
82.             // 处理K2按下后的10秒计时
83.             if (K2_pressed) {
84.                 K2_holdTime++;
85.                 if (K2_holdTime >= 10) {
86.                     K2_pressed = 0;
87.                     K2_holdTime = 0;
88.                     LED_override = 0; // 恢复正常LED状态
89.                 }
90.             }
91.             
92.             // 正常倒计时处理
93.             if (!countDownFinished) {
94.                 if (sec > 0) {
95.                     sec--;
96.                     
97.                     // 更新数码管显示
98.                     buf[0] = sec%10;
99.                     buf[1] = sec/10%10;
100.                     for (j=5; j>=1; j--) {
101.                         if (buf[j] == 0) LedBuff[j] = 0xFF;
102.                         else break;
103.                     }
104.                     for (; j>=0; j--) {
105.                         LedBuff[j] = LedChar[buf[j]];
106.                     }
107.                     
108.                     // 更新正常LED状态
109.                     if (countDownPhase == 0) { // 30秒阶段
110.                         if (sec > 3) normalLEDState = 0xDE; // LED1&6
111.                         else if (sec > 0) normalLEDState = 0xDD; // LED2&6
112.                         else normalLEDState = 0xFF;
113.                     }
114.                     else if (countDownPhase == 1) { // 20秒阶段
115.                         if (sec > 3) normalLEDState = 0xF3; // LED3&4
116.                         else if (sec > 0) normalLEDState = 0xEB; // LED3&5
117.                         else normalLEDState = 0xFF;
118.                     }
119.                 } else {
120.                     // 倒计时结束，切换到下一阶段
121.                     countDownFinished = 1;
122.                 }
123.             } else {
124.                 // 阶段切换处理
125.                 countDownPhase++;
126.                 if (countDownPhase == 1) { // 切换到20秒阶段
127.                     sec = 20;
128.                     countDownFinished = 0;
129.                     normalLEDState = 0xF3; // LED3&4
130.                 }
131.                 else if (countDownPhase >= 2) { // 循环回到30秒阶段
132.                     countDownPhase = 0;
133.                     sec = 30;
134.                     countDownFinished = 0;
135.                     normalLEDState = 0xDE; // LED1&6
136.                 }
137.                
138.                 // 更新数码管显示
139.                 buf[0] = sec%10;
140.                 buf[1] = sec/10%10;
141.                 for (j=5; j>=1; j--) {
142.                     if (buf[j] == 0) LedBuff[j] = 0xFF;
143.                     else break;
144.                 }
145.                 for (; j>=0; j--) {
146.                     LedBuff[j] = LedChar[buf[j]];
147.                 }
148.             }
149.         }
150.     }
151. }
153. void KeyScan()
154. {
155.     static unsigned char keyDebounceK1 = 0;
156.     static unsigned char keyDebounceK2 = 0;
157.    
158.     // 扫描第1行
159.     KEY_OUT_1 = 0;  // 选通第1行
160.     KEY_OUT_2 = 1;
161.     KEY_OUT_3 = 1;
162.     KEY_OUT_4 = 1;
163.    
164.     // 检测K1 (第1行第1列)
165.     if (KEY_IN_1 == 0) {
166.         keyDebounceK1++;
167.         if (keyDebounceK1 >= 5 && !K1_pressed && countDownPhase == 0 && sec >= 10) {
168.             K1_pressed = 1;
169.             K1_holdTime = 0;
170.             LED_override = 1;
171.             overrideLEDState = 0xF3; // LED3和LED4亮
172.         }
173.     } else {
174.         keyDebounceK1 = 0;
175.     }
176.    
177.     // 检测K2 (第1行第2列)
178.     if (KEY_IN_2 == 0) {
179.         keyDebounceK2++;
180.         if (keyDebounceK2 >= 5 && !K2_pressed && countDownPhase == 1 && sec >= 10) {
181.             K2_pressed = 1;
182.             K2_holdTime = 0;
183.             LED_override = 1;
184.             overrideLEDState = 0xDE; // LED1和LED6亮
185.         }
186.     } else {
187.         keyDebounceK2 = 0;
188.     }
189. }
191. void Timer0_ISR() interrupt 1
192. {
193.     static unsigned char i = 0;
194.     static unsigned int cnt = 0;
196.     TH0 = 0xFC;
197.     TL0 = 0x67;
198.    
199.     P0 = 0xFF;
200.     ENLED = 0;
201.     ADDR3 = 1;
203.     // 数码管动态扫描
204.     switch(i) {
205.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
206.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
207.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
208.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
209.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
210.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i++; P0=LedBuff[5]; break;
211.         case 6:
212.             ADDR2=1; ADDR1=1; ADDR0=0;
213.             
214.             // LED控制
215.             if (LED_override) {
216.                 P0 = overrideLEDState; // 使用覆盖的LED状态
217.             } else {
218.                 P0 = normalLEDState; // 正常LED状态
219.             }
220.             i = 0;
221.             break;
222.         default: break;
223.     }
225.     // 1秒定时
226.     cnt++;
227.     if (cnt >= 1000) {
228.         cnt = 0;
229.         flag1s = 1;
230.     }
231. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告