标题: stm32f103单片机固件库编程按键检测源码 [打印本页]

---

作者: xiexuedi    时间: 2018-10-25 22:03
标题: stm32f103单片机固件库编程按键检测源码
使用stm32f103的GPIO端口检查按键源码

源程序如下:

1. #include "stm32f10x.h" //头文件
   
2. #include "bsp_led.h"
   
3. #include "bsp_key.h"
   
4. 
   
5. #define    KEY1   KEY_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN)
   
6. #define    KEY2   KEY_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN)
   
7. char a;
   
8. char b;
   
9. 
   
10. void delay(uint32_t count)
    
11. {
    
12. for(;count!=0;count--);
    
13.    
    
14. 
    
15. }
    
16.         
    
17. void Output_Auto(void)
    
18. {
    
19. 
    
20. 
    
21.                 LED_R(ON);
    
22.         //        LED_G(ON);
    
23.         //        LED_B(ON);
    
24.                 delay(0x8FFFFF);
    
25.                 LED_R(OFF);
    
26.                 LED_G(OFF);
    
27.                 LED_B(OFF);
    
28. 
    
29.         //        LED_R(ON);
    
30.                 LED_G(ON);
    
31.         //        LED_B(ON);
    
32.                 delay(0x8FFFFF);
    
33.         //        LED_R(OFF);
    
34.                 LED_G(OFF);
    
35.                 LED_B(OFF);
    
36.         
    
37.         //        LED_R(ON);
    
38.         //        LED_G(ON);
    
39.                 LED_B(ON);
    
40.                 delay(0x8FFFFF);
    
41.         //        LED_R(OFF);
    
42.                 LED_G(OFF);
    
43.                 LED_B(OFF);
    
44.         
    
45.                 LED_R(ON);
    
46.                 LED_G(ON);
    
47.         //        LED_B(ON);
    
48.                 delay(0x8FFFFF);
    
49.                 LED_R(OFF);
    
50.                 LED_G(OFF);
    
51.         //        LED_B(OFF);
    
52.         
    
53.                 LED_R(ON);
    
54.         //        LED_G(ON);
    
55.                 LED_B(ON);
    
56.                 delay(0x8FFFFF);
    
57.                 LED_R(OFF);
    
58.         //        LED_G(OFF);
    
59.                 LED_B(OFF);
    
60.         
    
61.         //        LED_R(ON);
    
62.                 LED_G(ON);
    
63.                 LED_B(ON);
    
64.                 delay(0x8FFFFF);
    
65.         //        LED_R(OFF);
    
66.                 LED_G(OFF);
    
67.                 LED_B(OFF);
    
68.         
    
69.                 LED_R(ON);
    
70.                 LED_G(ON);
    
71.                 LED_B(ON);
    
72.                 delay(0x8FFFFF);
    
73.                 LED_R(OFF);
    
74.                 LED_G(OFF);
    
75.                 LED_B(OFF);
    
76.         
    
77.                                 
    
78.                 LED_R(OFF);
    
79.                 LED_G(OFF);
    
80.                 LED_B(OFF);
    
81.                 delay(0x8FFFFF);
    
82. 
    
83.         LED_R(ON);
    
84.                 LED_G(ON);
    
85.                 //LED_B(ON);
    
86.                 delay(0xCFFFD);
    
87.                 LED_R(OFF);
    
88.                 //LED_B();
    
89.                 delay(0xCFFFD);
    
90. 
    
91. 
    
92. 
    
93. }
    
94. void Output_R(void)
    
95. {
    
96. 
    
97.     LED_R(ON);
    
98.                 LED_G(OFF);
    
99.                 LED_B(OFF);
    
100. }
     
101. void Output_G(void)
     
102. {
     
103. 
     
104.     LED_R(OFF);
     
105.                 LED_G(ON);
     
106.                 LED_B(OFF);
     
107. }
     
108. void Output_B(void)
     
109. {
     
110. 
     
111.     LED_R(OFF);
     
112.                 LED_G(OFF);
     
113.                 LED_B(ON);
     
114. }
     
115. void Output_R_G(void)
     
116. {
     
117.   LED_R(ON);
     
118.         LED_G(ON);
     
119.         LED_B(OFF);
     
120. 
     
121. }
     
122. 
     
123. void Output_R_B(void)
     
124. {
     
125.   LED_R(ON);
     
126.         LED_G(OFF);
     
127.         LED_B(ON);
     
128. 
     
129. }
     
130. void Output_G_B(void)
     
131. {
     
132.   LED_R(OFF);
     
133.         LED_G(ON);
     
134.         LED_B(ON);
     
135. 
     
136. }
     
137. void Output_All(void)
     
138. {
     
139.         LED_R(ON);
     
140.         LED_G(ON);
     
141.         LED_B(ON);
     
142. 
     
143. }
     
144. void Output_Null(void)
     
145. {
     
146.   LED_R(OFF);
     
147.         LED_G(OFF);
     
148.         LED_B(OFF);
     
149. 
     
150. }
     
151. int main(void)
     
152. {
     
153.         a=0;
     
154.         b=0;
     
155.         LED_GPIO_Config();
     
156.         KEY_GPIO_Config();
     
157.         LED_R(OFF);
     
158.         LED_G(OFF);
     
159.         LED_B(OFF);
     
160.         while(1)
     
161.                 {
     
162.              if(KEY1 == KEY_ON)
     
163.                             {
     
164.                                                 delay(0x1FFF);
     
165.                                                 //a=1;
     
166.                                                 if(KEY1 == KEY_ON && b == 0)
     
167.               {
     
168.                      Output_R();
     
169.                                                                       b =1;
     
170.                                                         }
     
171.                                     else if(KEY1 == KEY_ON && b == 1)
     
172.                                                      {
     
173.                                                                         
     
174.                     Output_G();
     
175.                                                                        b =2;
     
176.                                                                     }
     
177.             else if(KEY1 == KEY_ON && b == 2)
     
178.                  {
     
179.                                                                         
     
180.                             Output_B();
     
181.                                                                              b = 3;
     
182.                                                              }
     
183.             else if(KEY1 == KEY_ON && b == 3)
     
184.                  {
     
185.                                                                         
     
186.                             Output_R_G();
     
187.                                                                              b = 4;
     
188.                                                              }
     
189.             else if(KEY1 == KEY_ON && b == 4)
     
190.                  {
     
191.                                                                         
     
192.                             Output_R_B();
     
193.                                                                              b = 5;
     
194.                                                              }
     
195.             else if(KEY1 == KEY_ON && b == 5)
     
196.                  {
     
197.                                                                         
     
198.                             Output_G_B();
     
199.                                                                              b = 6;        
     
200.                                                              }               
     
201.             else if(KEY1 == KEY_ON && b == 6)
     
202.                  {
     
203.                                                                         
     
204.                             Output_All();
     
205.                                                                             b = 7;
     
206.                                                              }                                                                 
     
207.                                                 else if(KEY1 == KEY_ON && b == 7)
     
208.                  {
     
209.                                                                         
     
210.                             Output_Null();
     
211.                                                                              b = 0;
     
212.                                                              }                                       
     
213.                                    // else a=0;
     
214.                                                                                          }
     
215.                           if(KEY2==KEY_ON)
     
216.                             {   
     
217.                                                 delay(0x0FFF);
     
218.                               if(KEY2==KEY_ON)
     
219.                                  {  
     
220.                                                                  Output_Auto();
     
221.                        }
     
222.                                                          else Output_Null();
     
223.                                                                                  }
     
224.                                        
     
225.         
     
226.                 }
     
227.    
     
228.      
     
229. 
     
230.         
     
231. 
     
232. }
     

复制代码

所有资料51hei提供下载:
13-GPIO输入-按键检测.rar (283.18 KB, 下载次数: 8)

2018-10-25 23:17 上传

点击文件名下载附件
程序源码
下载积分: 黑币 -5

---

作者: admin    时间: 2018-10-25 23:17
补全原理图或者详细说明一下电路连接即可获得100+黑币

---

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

Powered by Discuz! X3.1