【原创】用C控制GPIO的代码[可以直接看CPU占用率了]

soloforce

现在不需要通过写IO文件来操作GPIO了，请参考这个帖子：http://forum.cubietech.com/forum.php?mod=viewthread&tid=464&page=1&extra=#pid2719

---

写了个C语言控制GPIO的代码，目前只支持数字IO（只有0和1）,分享一下。API模仿Arduino的风格，比较简单易用。

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. 
   
8. /**
   
9. * Here we use the GPIO expansion near the SATA connector, from PD1 ~ PD7
   
10. * */
    
11. #define MIN_PIN 1
    
12. #define MAX_PIN 7
    
13. 
    
14. /**
    
15. * Binary value that GPIO pins could accept
    
16. * */
    
17. typedef enum{
    
18.     LOW=0,
    
19.     HIGH=1
    
20. }value_t;
    
21. 
    
22. /**
    
23. * GPIO pins get/set direction
    
24. * */
    
25. typedef enum{
    
26.    IN=0,
    
27.    OUT=1
    
28. }direction_t;
    
29. 
    
30. FILE* value_fp[MAX_PIN+1];
    
31. 
    
32. /**
    
33. * @brief Initialize the GPIO ports' value file pointers
    
34. *
    
35. * */
    
36. void gpio_init()
    
37. {
    
38.     int i;
    
39.     for(i=MIN_PIN;i<=MAX_PIN;i++)
    
40.         value_fp[i]=NULL;
    
41. }
    
42. 
    
43. /**
    
44. * @brief Uninitialize the GPIO ports, unexport those exported and close files.
    
45. *
    
46. * */
    
47. int gpio_uninit()
    
48. {
    
49.     int i;
    
50.     FILE *unexport_fp=fopen("/sys/class/gpio/unexport","w");
    
51.     if(!unexport_fp) return -1;
    
52. 
    
53.     for(i=MIN_PIN;i<=MAX_PIN;i++){
    
54.         if(value_fp[i]){
    
55.             fclose(value_fp[i]);
    
56.             fprintf(unexport_fp,"%d",i);
    
57.             fflush(unexport_fp);
    
58.         }   
    
59.     }
    
60. 
    
61.     fclose(unexport_fp);
    
62. 
    
63.     return 0;
    
64. }
    
65. 
    
66. /**
    
67. * @brief Set the GPIO pins to specified direction
    
68. *
    
69. * @param pin: GPIO pin to set direction
    
70. * @param dir: IN or OUT
    
71. *
    
72. * */
    
73. int pinMode(int pin, direction_t dir)
    
74. {
    
75.     char direction_file[64];
    
76.     char value_file[64];
    
77. 
    
78.     FILE *export_fp=fopen("/sys/class/gpio/export","w");
    
79.     if(!export_fp) return -1;
    
80.    
    
81.     fprintf(export_fp,"%d",pin);
    
82.     sleep(1);
    
83.     fclose(export_fp);
    
84. 
    
85.     sprintf(direction_file,"/sys/class/gpio/gpio%d_pd%d/direction", pin, pin);
    
86.     FILE *direction_fp=fopen(direction_file,"w");
    
87.     if(!direction_fp) return -2;
    
88. 
    
89.     if(dir==OUT){
    
90.         fprintf(direction_fp,"out");
    
91.     }else fprintf(direction_fp,"in");
    
92. 
    
93.     fclose(direction_fp);
    
94. 
    
95.     sprintf(value_file,"/sys/class/gpio/gpio%d_pd%d/value", pin, pin);
    
96.     value_fp[pin]=fopen(value_file,"w");
    
97. 
    
98.     if(!value_fp[pin]) return -3;
    
99. 
    
100. 
     
101.     return 0;
     
102. 
     
103. }
     
104. 
     
105. /**
     
106. * @brief Set the GPIO pins to specified binary value
     
107. *
     
108. * @param pin: GPIO pin to set value
     
109. * @param value: LOW or HIGH
     
110. *
     
111. * */
     
112. int digitalWrite(int pin, value_t value)
     
113. {
     
114. 
     
115.     if(!value_fp[pin])return -1;
     
116. 
     
117.     if(pin<MIN_PIN) pin=MIN_PIN;
     
118.     if(pin>MAX_PIN) pin=MAX_PIN;
     
119. 
     
120.     fprintf(value_fp[pin],"%d", value);
     
121.     fflush(value_fp[pin]);
     
122. 
     
123.     return 0;
     
124. }
     
125. 
     
126. /**
     
127. * @brief A demo to alternately set two GPIO pin's power level (LOW or HIGH),
     
128. *       to flash a LED connected between the two pins.
     
129. * */
     
130. int main()
     
131. {
     
132.     gpio_init();
     
133. 
     
134.     pinMode(1,OUT);
     
135.     pinMode(2,OUT);
     
136. 
     
137.     int i;
     
138.     for(i=0;i<10;i++){
     
139.         digitalWrite(1,HIGH);
     
140.         digitalWrite(2,LOW);
     
141.         sleep(1);
     
142. 
     
143.         digitalWrite(1,LOW);
     
144.         digitalWrite(2,HIGH);
     
145.         sleep(1);
     
146.     }
     
147. 
     
148.     gpio_uninit();
     
149. }
     

复制代码

soloforce

再发一个用GPIO控制LED显示当前CPU繁忙情况的小程序。

在GPIO的LD1~LD6接了3只LED，以二进制码形式显示CPU使用率。

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <unistd.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. #include <string.h>
   
8. #include <signal.h>
   
9. 
   
10. 
    
11. /**
    
12. * Here we use the GPIO expansion near the SATA connector, from PD1 ~ PD7
    
13. * */
    
14. #define MIN_PIN 1
    
15. #define MAX_PIN 7
    
16. 
    
17. /**
    
18. * Binary value that GPIO pins could accept
    
19. * */
    
20. typedef enum{
    
21.     LOW=0,
    
22.     HIGH=1
    
23. }value_t;
    
24. 
    
25. /**
    
26. * GPIO pins get/set direction
    
27. * */
    
28. typedef enum{
    
29.    IN=0,
    
30.    OUT=1
    
31. }direction_t;
    
32. 
    
33. typedef struct{
    
34.     long int user,nice,sys,idle,iowait,irq,softirq;
    
35. }jiffies_t;
    
36. 
    
37. 
    
38. /**
    
39. * GPIO pin values' file pointers
    
40. * */
    
41. FILE* value_fp[MAX_PIN+1]={NULL};
    
42. 
    
43. /**
    
44. * Signal actions structures
    
45. * */
    
46. struct sigaction int_act,term_act, old_act;
    
47. 
    
48. 
    
49. /**
    
50. * @brief Signal INT handler
    
51. * */
    
52. void sigint_handler(int sig_num)
    
53. {
    
54.     printf("Uninitialzing GPIO...\n");
    
55. 
    
56.     /* uninitialize the GPIO */
    
57.     gpio_uninit();
    
58. 
    
59.     /* change back to the original handler */
    
60.     sigaction(SIGINT, &old_act,NULL);
    
61. 
    
62.    
    
63.     /* emit the SIGINT again */
    
64.     kill(0,SIGINT);
    
65. }
    
66. 
    
67. /**
    
68. * @brief Signal TERM handler
    
69. * */
    
70. void sigterm_handler(int sig_num)
    
71. {
    
72.     printf("Uninitialzing GPIO...\n");
    
73. 
    
74.     /* uninitialize the GPIO */
    
75.     gpio_uninit();
    
76. 
    
77.     /* change back to the original handler */
    
78.     sigaction(SIGTERM, &old_act,NULL);
    
79. 
    
80.     /* emit the SIGTERM again */
    
81.     kill(0,SIGTERM);
    
82. }
    
83. 
    
84. 
    
85. /**
    
86. * @brief Initialize signals
    
87. * * */
    
88. void catch_signal_init()
    
89. {
    
90.     memset(&int_act,0,sizeof(int_act));
    
91.     memset(&term_act,0,sizeof(int_act));
    
92.     memset(&old_act,0,sizeof(old_act));
    
93.     int_act.sa_handler=&sigint_handler;
    
94.     term_act.sa_handler=&sigterm_handler;
    
95.     sigaction(SIGINT, &int_act, &old_act);
    
96.     sigaction(SIGTERM, &term_act, &old_act);
    
97. }
    
98. 
    
99. 
    
100. /**
     
101. * @brief Initialize the GPIO ports' value file pointers
     
102. *
     
103. * */
     
104. void gpio_init()
     
105. {
     
106.     int i;
     
107.     for(i=MIN_PIN;i<=MAX_PIN;i++)
     
108.         value_fp[i]=NULL;
     
109. 
     
110.     pinMode(1,OUT);
     
111.     pinMode(2,OUT);
     
112.     pinMode(3,OUT);
     
113.     pinMode(4,OUT);
     
114.     pinMode(5,OUT);
     
115.     pinMode(6,OUT);
     
116. }
     
117. 
     
118. /**
     
119. * @brief Uninitialize the GPIO ports, unexport those exported and close files.
     
120. *
     
121. * */
     
122. int gpio_uninit()
     
123. {
     
124.     int i;
     
125.     FILE *unexport_fp=fopen("/sys/class/gpio/unexport","w");
     
126.     if(!unexport_fp) return -1;
     
127. 
     
128.     for(i=MIN_PIN;i<=MAX_PIN;i++){
     
129.         if(value_fp[i]){
     
130.             fclose(value_fp[i]);
     
131.             fprintf(unexport_fp,"%d",i);
     
132.             fflush(unexport_fp);
     
133.         }   
     
134.     }
     
135. 
     
136.     fclose(unexport_fp);
     
137. 
     
138.     return 0;
     
139. }
     
140. 
     
141. /**
     
142. * @brief Set the GPIO pins to specified direction
     
143. *
     
144. * @param pin: GPIO pin to set direction
     
145. * @param dir: IN or OUT
     
146. *
     
147. * */
     
148. int pinMode(int pin, direction_t dir)
     
149. {
     
150.     char direction_file[64];
     
151.     char value_file[64];
     
152. 
     
153.     FILE *export_fp=fopen("/sys/class/gpio/export","w");
     
154.     if(!export_fp) return -1;
     
155.    
     
156.     fprintf(export_fp,"%d",pin);
     
157.     sleep(1);
     
158.     fclose(export_fp);
     
159. 
     
160.     sprintf(direction_file,"/sys/class/gpio/gpio%d_pd%d/direction", pin, pin);
     
161.     FILE *direction_fp=fopen(direction_file,"w");
     
162.     if(!direction_fp) return -2;
     
163. 
     
164.     if(dir==OUT){
     
165.         fprintf(direction_fp,"out");
     
166.     }else fprintf(direction_fp,"in");
     
167. 
     
168.     fclose(direction_fp);
     
169. 
     
170.     sprintf(value_file,"/sys/class/gpio/gpio%d_pd%d/value", pin, pin);
     
171.     value_fp[pin]=fopen(value_file,"w");
     
172. 
     
173.     if(!value_fp[pin]) return -3;
     
174. 
     
175. 
     
176.     return 0;
     
177. 
     
178. }
     
179. 
     
180. /**
     
181. * @brief Set the GPIO pins to specified binary value
     
182. *
     
183. * @param pin: GPIO pin to set value
     
184. * @param value: LOW or HIGH
     
185. *
     
186. * */
     
187. int digitalWrite(int pin, value_t value)
     
188. {
     
189. 
     
190.     if(!value_fp[pin])return -1;
     
191. 
     
192.     if(pin<MIN_PIN) pin=MIN_PIN;
     
193.     if(pin>MAX_PIN) pin=MAX_PIN;
     
194. 
     
195.     fprintf(value_fp[pin],"%d", value);
     
196.     fflush(value_fp[pin]);
     
197. 
     
198.     return 0;
     
199. }
     
200. 
     
201. /**
     
202. * @brief Get CPU jiffies from /proc/stat
     
203. *
     
204. * @param s(OUTPUT) Point of CPU jiffies structure
     
205. *
     
206. * */
     
207. int get_jiffies(jiffies_t *s)
     
208. {
     
209.     char buf[128]={0};
     
210.     char cpu[8]={0};
     
211. 
     
212.     if(!s) return -1;
     
213.     FILE* cpu_stat_fp = fopen("/proc/stat","r");
     
214.     if(cpu_stat_fp == NULL){
     
215.         return -1;
     
216.     }
     
217. 
     
218.     fgets(buf,sizeof(buf),cpu_stat_fp);
     
219.     sscanf(buf,"%s%d%d%d%d%d%d%d",cpu, &(s->user),&(s->nice),&(s->sys),&(s->idle),&(s->iowait),&(s->irq),&(s->softirq));
     
220. 
     
221.     fclose(cpu_stat_fp);
     
222.     return 0;
     
223. }
     
224. 
     
225. /**
     
226. * @brief Get CPU usage
     
227. *
     
228. * @param usage(OUTPUT): CPU usage in a short time
     
229. *
     
230. * */
     
231. int get_cpu_usage(float * usage)
     
232. {
     
233.     jiffies_t j1,j2;
     
234.     float all1, all2;
     
235.     int status;
     
236. 
     
237.     if(!usage) return -1;
     
238. 
     
239.     status=get_jiffies(&j1);
     
240.     if(status) return -2;
     
241.     usleep(100000);
     
242.     status=get_jiffies(&j2);
     
243.     if(status) return -2;
     
244. 
     
245.    
     
246.     all1=j1.user+j1.nice+j1.sys+j1.idle+j1.iowait+j1.irq+j1.softirq;
     
247.     all2=j2.user+j2.nice+j2.sys+j2.idle+j2.iowait+j2.irq+j2.softirq;
     
248. 
     
249.     *usage=((all2-j2.idle)-(all1-j1.idle))/(all2-all1) ;
     
250. 
     
251.     return 0;
     
252. }
     
253. 
     
254. /**
     
255. * @brief Show CPU usage to LEDs in binary-mode
     
256. *
     
257. * @param n(INPUT): CPU usage level, from 0~7
     
258. *
     
259. * */
     
260. void show_cpu_usage(int n)
     
261. {
     
262. 
     
263.     if(n & 0x04){
     
264.         digitalWrite(1,LOW);
     
265.         digitalWrite(2,HIGH);
     
266.     }else{
     
267.         digitalWrite(1,HIGH);
     
268.         digitalWrite(2,LOW);
     
269.     }
     
270. 
     
271. 
     
272.     if(n & 0x02){
     
273.         digitalWrite(3,LOW);
     
274.         digitalWrite(4,HIGH);
     
275.     }else{
     
276.         digitalWrite(3,HIGH);
     
277.         digitalWrite(4,LOW);
     
278.     }
     
279. 
     
280. 
     
281.     if(n & 0x01){
     
282.         digitalWrite(5,LOW);
     
283.         digitalWrite(6,HIGH);
     
284.     }else{
     
285.         digitalWrite(5,HIGH);
     
286.         digitalWrite(6,LOW);
     
287.     }
     
288. }
     
289. 
     
290. 
     
291. 
     
292. /**
     
293. * @brief A daemon to show CPU usage through GPIO expansion
     
294. *       to flash a LED connected between the two pins. Press Ctrl+C to Quit.
     
295. * */
     
296. int main()
     
297. {
     
298.     float usage;
     
299.     pid_t pid=fork();
     
300.    
     
301. 
     
302.     /* Create a daemon process, and terminate the parent process. */
     
303.     if(pid>0) exit(0);
     
304.     if(pid<0) {
     
305.         printf("Failed to create sub-process!\n");
     
306.         exit(-1);
     
307.     }
     
308.     setsid();
     
309.     catch_signal_init();
     
310.     gpio_init();
     
311.    
     
312.     while(1){
     
313.         if(get_cpu_usage(&usage)){
     
314.             printf("Failed to get CPU usage!\n");
     
315.             break;
     
316.         }
     
317. 
     
318.         int n=(int)(usage*8);
     
319.         if(n>7) n=7;
     
320.         show_cpu_usage(n);
     
321.         sleep(1);
     
322.     }
     
323. 
     
324.    
     
325. }
     

复制代码

cubieplayer

赞！代码很工整

jarry

{:soso_e100:} 看到使用了两种不同函数命名规则 ：）

hipboi

unix风格和arduino风格。。。

gootoomoon

有没有可能把树莓派的 WiringPi 直接移植过来？ 貌似他们的东西做得挺全的，有机会可以探讨一下

pc3000

学习了，这个也是直接调用Python GPIO库？

tll

特别喜欢arduino风格，和以前我学的Action Script 2&3很像~

寒寒

py的库好像内容不丰富啊

f839903061

版主有没有android的gpio的读写工具类或者源码
I2C读写的工具栏或源码呢？能否发一份呢？


谢谢！