嵌入式监控系统喷水模块的设计（含程序代码）

嵌入式监控系统中很重要的一个环节就是当有人闯入和有火灾生时候，需要进行报警并喷水，今天我给大家写一个模块的设计。

设计中将四个LED灯与S3C2410处理器的四个管脚相连接，由于GPIO是复用管脚，所以首先进行相应寄存器的配置，也就是首先配置控制寄存器GPFCON，配置为output.然后就是对灯的相应控制，这个是对数据寄存器GPFDAT,如果写0，led灯亮。否则灯灭。

软件是通过ioctl进行相应的控制。

原理图

红外模块驱动流程图

详细代码设计

1. #include <linux/config.h>
   
2. 
   
3. #include <linux/module.h>
   
4. 
   
5. #include <linux/init.h>
   
6. 
   
7. #include <linux/fs.h>
   
8. 
   
9. #include <linux/cdev.h>
   
10. 
    
11. #include <linux/ioctl.h>
    
12. 
    
13. #include <asm/uaccess.h>
    
14. 
    
15. #include <asm/hardware.h>
    
16. 
    
17. #include <asm/arch/regs-gpio.h>
    
18. 
    
19. #include <asm-arm/irq.h>
    
20. 
    
21. #include <asm-arm/arch-s3c2410/irqs.h>
    
22. 
    
23. #include <linux/interrupt.h>
    
24. 
    
25. #include <asm/io.h>
    
26. 
    
27. 
    
28. 
    
29. MODULE_LICENSE("GPL");
    
30. 
    
31. #define GPFCON *(volatile unsigned int *)S3C2410_GPFCON
    
32. 
    
33. //#define GPBDAT *(volatile unsigned int *)S3C2410_GPBDAT
    
34. 
    
35. 
    
36. 
    
37. static int led_major=0;
    
38. 
    
39. 
    
40. 
    
41. 
    
42. 
    
43. static int led_open(struct inode *inode ,struct file *file)
    
44. 
    
45. {  
    
46. 
    
47.    
    
48. 
    
49.     GPFCON &=(~(3<<6));
    
50. 
    
51.    
    
52. 
    
53.     //printk("GPFCON is %x\n",GPFCON);
    
54. 
    
55.    
    
56. 
    
57.     return 0;
    
58. 
    
59. }
    
60. 
    
61. 
    
62. 
    
63. static ssize_t led_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
    
64. 
    
65. {
    
66. 
    
67.     int flags=0;
    
68. 
    
69.     int ret;
    
70. 
    
71.     //  writel(0,S3C2410_GPFDAT);
    
72. 
    
73.     ret = readl(S3C2410_GPFDAT);
    
74. 
    
75.     //printk("！flags is %x\n",ret&(1<<3));
    
76. 
    
77.     if((ret & (1<<3)) == 8)
    
78. 
    
79.     {
    
80. 
    
81.     //printk("in flags =1 ?\n");
    
82. 
    
83.     flags=1;
    
84. 
    
85.     copy_to_user(buffer, &flags, sizeof(flags));    }
    
86. 
    
87.     else
    
88. 
    
89.         copy_to_user(buffer,(char *)&flags,sizeof(flags));
    
90. 
    
91.     return sizeof(flags);
    
92. 
    
93. }
    
94. 
    
95. 
    
96. 
    
97. 
    
98. 
    
99. static int led_release(struct inode *inode,struct file *file)
    
100. 
     
101. {
     
102. 
     
103.     return 0;
     
104. 
     
105. }
     
106. 
     
107. 
     
108. 
     
109. 
     
110. 
     
111. static void led_setup_cdev(struct cdev *dev,int minor,struct file_operations *fops)
     
112. 
     
113. {
     
114. 
     
115.     int err;
     
116. 
     
117.     int devno=MKDEV(led_major,minor);
     
118. 
     
119.     cdev_init(dev,fops);
     
120. 
     
121.     dev->owner=THIS_MODULE;
     
122. 
     
123.     dev->ops=fops;
     
124. 
     
125.     err=cdev_add(dev,devno,1);
     
126. 
     
127.     if(err)
     
128. 
     
129.     printk(KERN_INFO"Error %d adding led %d\n",err,minor);
     
130. 
     
131. }
     
132. 
     
133. 
     
134. 
     
135.       
     
136. 
     
137. static struct file_operations led_remap_ops={
     
138. 
     
139.        .owner=THIS_MODULE,
     
140. 
     
141.        .open=led_open,     
     
142. 
     
143. .release=led_release,     
     
144. 
     
145. .read = led_read,
     
146. 
     
147.       
     
148. 
     
149. };
     
150. 
     
151. 
     
152. 
     
153. static struct cdev SimpleDevs;
     
154. 
     
155. 
     
156. 
     
157. 
     
158. 
     
159. static int led_init(void)
     
160. 
     
161. {
     
162. 
     
163.     int result;
     
164. 
     
165.     //int ret;
     
166. 
     
167.     dev_t dev=MKDEV(led_major,0);
     
168. 
     
169.     if(led_major)
     
170. 
     
171.      result=register_chrdev_region(dev,1,"led");
     
172. 
     
173.        else
     
174. 
     
175.         {
     
176. 
     
177.               result=alloc_chrdev_region(&dev,0,1,"led");      led_major=MAJOR(dev);
     
178. 
     
179.      }
     
180. 
     
181.     if(result<0)
     
182. 
     
183.      {
     
184. 
     
185.       printk(KERN_WARNING"led:unable to get major %d\n",led_major);   
     
186. 
     
187.       return result;
     
188. 
     
189.      }
     
190. 
     
191.     if(led_major==0)
     
192. 
     
193.     led_major=result;   printk(KERN_INFO"led register ok！\n");
     
194. 
     
195.     //ret = request_irq(IRQ_EINT19, button_irq, SA_INTERRUPT, "led", NULL);
     
196. 
     
197.     led_setup_cdev(&SimpleDevs,0,&led_remap_ops);
     
198. 
     
199.     return 0;
     
200. 
     
201. }
     
202. 
     
203. 
     
204. 
     
205. static void led_exit(void)
     
206. 
     
207. {
     
208. 
     
209.     cdev_del(&SimpleDevs);
     
210. 
     
211.     unregister_chrdev_region(MKDEV(led_major,0),2);
     
212. 
     
213.     printk("led device uninstalled\n");
     
214. 
     
215. }
     
216. 
     
217. module_init(led_init);
     
218. 
     
219. module_exit(led_exit);
     
220. 
     
221. 2.测试模块程序设计
     
222. 
     
223. #include <stdio.h>
     
224. 
     
225. #include <sys/types.h>
     
226. 
     
227. #include <unistd.h>
     
228. 
     
229. #include <fcntl.h>
     
230. 
     
231. #include <time.h>
     
232. 
     
233. #include <sys/ioctl.h>
     
234. 
     
235. 
     
236. 
     
237. int main(void)
     
238. 
     
239. {
     
240. 
     
241.     int fd,i,j;
     
242. 
     
243.     int flags=0;
     
244. 
     
245.     j=0;
     
246. 
     
247.     fd=open("/dev/led",O_RDWR); //打开设备驱动程序
     
248. 
     
249.     //进行打开操作的判断
     
250. 
     
251.     if(fd<0)
     
252. 
     
253.         {
     
254. 
     
255.         printf("led open failed\n");
     
256. 
     
257.         exit(0);
     
258. 
     
259.         }
     
260. 
     
261.       
     
262. 
     
263.     while(1)
     
264. 
     
265.     {  
     
266. 
     
267.     read(fd,&flags,1);
     
268. 
     
269.                     printf("flags is %d\n",flags);
     
270. 
     
271.     sleep(1);
     
272. 
     
273.     }
     
274. 
     
275.     close(fd);//关闭设备
     
276. 
     
277.     return 0;
     
278. 
     
279. }

转自《电子技术应用》

LED的linux驱动以及测试。

嗯，被你看出来了