标题: 51单片机按键控制花式流水灯程序 Proteus仿真图 [打印本页]

---

作者: 林中白狼..    时间: 2025-1-7 19:02
标题: 51单片机按键控制花式流水灯程序 Proteus仿真图
实现按键控制花式流水灯，仅供学习可用，一个完整的学习工程

1、HardWare文档中存放着需要添加进去的硬件和初始化的代码工程
2、HexFile文档中存放着生成的hex文件
3、Project文档中存放着启动文件和工程文件
4、UserMain文档中存放着main函数代码

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include "reg51.h"
   
2. #include "led.h"
   
3. #include "delay.h"
   
4. 
   
5. typedef unsigned char u8;
   
6. sbit KEY1=P2^0;
   
7. sbit KEY2=P2^1;
   
8. sbit KEY3=P2^2;
   
9. sbit KEY4=P2^3;
   
10. sbit KEY5=P2^4;
    
11. sbit KEY6=P2^5;
    
12. 
    
13. unsigned char flag = 0;
    
14. 
    
15. 
    
16. //串口初始化，设置波特率为9600，使用定时器1,晶振频率11.0592Mhz
    
17. void UART_Init()
    
18. {
    
19.         SCON=0X50;                        //设置为工作方式1
    
20.         TMOD=0X20;                        //设置计数器工作方式2
    
21.         PCON=0X80;                        //波特率加倍
    
22.         TH1=0XF3;                                //计数器初始值设置，注意波特率是9600
    
23.         TL1=0XF3;
    
24.         ES=1;                                                //打开接收中断
    
25.         EA=1;                                                //打开总中断
    
26.         TR1=1;                                        //打开计数器
    
27. }
    
28. 
    
29. 
    
30. 
    
31. void UART_Send_Data(u8 byte)
    
32. {
    
33.         SBUF=byte;
    
34.         while(!TI);//等待串口数据发送完毕
    
35.         TI=0;//将发送中断标志位清0，为下次发送数据做准备
    
36. }
    
37. 
    
38. 
    
39. 
    
40. void UART_SendString(unsigned char *str)  //串口发送字符串函数
    
41. {
    
42.     while(*str!='\0')     //判断字符串截止位则退出
    
43.         {
    
44.                 UART_Send_Data(*str);  
    
45.                 str++;
    
46.         }
    
47. }
    
48. 
    
49. 
    
50. 
    
51. 
    
52. void main()
    
53. {
    
54.         UART_Init();
    
55.         Led_Init();
    
56. 
    
57.         while(1)
    
58.         {
    
59.                 //UART_Send_Data(0x01);
    
60. 
    
61.                 if(KEY1==0){
    
62.                         delay_ms(10);
    
63.                         if(KEY1==0){
    
64.                                 UART_Send_Data(0x01);
    
65.                            flag=1;
    
66.                         }
    
67.                 }
    
68.                 if(KEY2==0){
    
69.                         delay_ms(10);
    
70.                         if(KEY2==0){
    
71.                                 UART_Send_Data(0x02);
    
72.                            flag=2;
    
73.                         }
    
74.                 }
    
75.                 if(KEY3==0){
    
76.                         delay_ms(10);
    
77.                         if(KEY3==0){
    
78.                                 UART_Send_Data(0x03);
    
79.                            flag=3;
    
80.                         }
    
81.                 }
    
82.                 if(KEY4==0){
    
83.                         delay_ms(10);
    
84.                         if(KEY4==0){
    
85.                                 UART_Send_Data(0x04);
    
86.                            flag=4;
    
87.                         }
    
88.                 }
    
89.                 if(KEY5==0){
    
90.                         delay_ms(10);
    
91.                         if(KEY5==0){
    
92.                                 UART_Send_Data(0x05);
    
93.                            flag=5;
    
94.                         }
    
95.                 }
    
96.                 if(KEY6==0){
    
97.                         delay_ms(10);
    
98.                         if(KEY6==0){
    
99.                                 UART_Send_Data(0x06);
    
100.                            flag=0;
     
101.                         }
     
102.                 }
     
103. 
     
104. 
     
105.                 switch(flag)
     
106.                 {
     
107.                         case 0:{
     
108.                                 LED0 = 1;
     
109.                                 LED1 = 1;
     
110.                                 LED2 = 1;
     
111.                                 LED3 = 1;
     
112.                                 LED4 = 1;
     
113.                                 LED5 = 1;
     
114.                                 LED6 = 1;
     
115.                                 LED7 = 1;
     
116.                         }break;
     
117. 
     
118.                         case 1:{
     
119.                                 LED0 = !LED0;
     
120.                                 delay_ms(50);
     
121.                                 LED2 = !LED2;
     
122.                                 delay_ms(50);
     
123.                                 LED4 = !LED4;
     
124.                                 delay_ms(50);
     
125.                                 LED6 = !LED6;
     
126.                                 delay_ms(50);
     
127.                         }break;
     
128. 
     
129.                         case 2:{
     
130.                                 LED1 = !LED1;
     
131.                                 delay_ms(50);
     
132.                                 LED3 = !LED3;
     
133.                                 delay_ms(50);
     
134.                                 LED5 = !LED5;
     
135.                                 delay_ms(50);
     
136.                                 LED7 = !LED7;
     
137.                                 delay_ms(50);
     
138.                         }break;
     
139. 
     
140.                         case 3:{
     
141.                                 LED1 = !LED1;
     
142.                                 delay_ms(50);
     
143.                                 LED2 = !LED2;
     
144.                                 delay_ms(50);
     
145.                                 LED3 = !LED3;
     
146.                                 delay_ms(50);
     
147.                         }break;
     
148. 
     
149.                         case 4:{
     
150.                                 LED4 = !LED4;
     
151.                                 delay_ms(50);
     
152.                                 LED5 = !LED5;
     
153.                                 delay_ms(50);
     
154.                                 LED6 = !LED6;
     
155.                                 delay_ms(50);
     
156.                         }break;
     
157. 
     
158.                         case 5:{
     
159.                                 LED0 = 0;
     
160.                                 LED1 = 0;
     
161.                                 LED2 = 0;
     
162.                                 LED3 = 0;
     
163.                                 LED4 = 0;
     
164.                                 LED5 = 0;
     
165.                                 LED6 = 0;
     
166.                                 LED7 = 0;
     
167.                                 delay_ms(100);
     
168.                                 LED0 = 1;
     
169.                                 LED1 = 1;
     
170.                                 LED2 = 1;
     
171.                                 LED3 = 1;
     
172.                                 LED4 = 1;
     
173.                                 LED5 = 1;
     
174.                                 LED6 = 1;
     
175.                                 LED7 = 1;
     
176.                                 delay_ms(100);
     
177.                         }break;
     
178.                 }
     
179.         }        
     
180. }
     
181. 
     
182. void Usart() interrupt 4
     
183. {
     
184.         u8 receiveData;
     
185. 
     
186.         receiveData=SBUF;//出去接收到的数据
     
187.         RI = 0;//清除接收中断标志位
     
188.         if(receiveData == 0x01)
     
189.         {
     
190.                 flag = 1;        
     
191.         }
     
192.         else if(receiveData == 0x02)
     
193.         {
     
194.                 flag = 2;        
     
195.         }
     
196.         else if(receiveData == 0x03)
     
197.         {
     
198.                 flag = 3;        
     
199.         }
     
200.         else if(receiveData == 0x04)
     
201.         {
     
202.                 flag = 4;        
     
203.         }
     
204.         else if(receiveData == 0x05)
     
205.         {
     
206.                 flag = 5;        
     
207.         }
     
208.         else{flag = 0;}
     
209.         //SBUF=receiveData;//将接收到的数据放入到发送寄存器
     
210.         while(!TI);                         //等待发送数据完成
     
211.         TI=0;                                                 //清除发送完成标志位
     
212. }

复制代码

仿真程序: 01.7z (59.39 KB, 下载次数: 0)

2025-1-9 04:24 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1