[BB方案]第三辑——用设备驱动控制LED

sjtitr

[BB方案]第三辑——用设备驱动控制LED [复制链接]

其实一直没看到楼主真正的做出些什么。                                 ——楼主 这些小儿科的实验，真真儿体现了楼主这矬货的水平。                                 ——楼主

上一辑，楼主终于实现了一个linux的驱动程序——只不过是个假的。

这一次，楼主要更进一步，利用这个驱动程序，来控制真正的硬件。

本期可能是唯一的一辑没有槽点的吧。

正式开始。

首先要确定一下到底是使用什么硬件……后来楼主终于在破烂堆里找到了一个led，好，就来它啦。

参照手册里下面这两张图，楼主也搭建了测试用的电路，没错一样一样的，楼主用的面包板和它不一样而已，LED的颜色好像也不一样。
好像它用了100欧的电阻，这个楼主实在是没有，于是拿了个470欧的。






恩，没错，用了GPIO44

BBB真的铺垫了很多事情，以至于我控制IO口根本不需要看芯片手册，操作文件就好了：

第一步：向/sys/class/gpio/export写入要控制的GPIO号，这里直接写入44

1.                 filp = filp_open("/sys/class/gpio/export",O_WRONLY,0);
   
2.                 filp->f_op->write(filp, "44", 3, &filp->f_pos);
   
3.                 filp_close(filp, NULL);

复制代码

这样就在其目录出现了相应GPIO的目录和文件

第二步：向/sys/class/gpio/gpio44/direction写入相应GPIO的方向

1. 
   
2.                 filp = filp_open("/sys/class/gpio/gpio44/direction",O_WRONLY,0);
   
3.                 filp->f_op->write(filp, "out", 4, &filp->f_pos);
   
4.                 filp_close(filp, NULL);

复制代码

第三步就可以写入0和1到/sys/class/gpio/gpio44/value，以控制该pin的输出电平啦。

当然，楼主实现了LED闪动的效果，闪动的频率是可以改变的，所以需要有一个timer

1. 
   
2.                 init_timer(&this_drv_timer);
   
3.                 this_drv_timer.function = timer_handler;
   
4.                 this_drv_timer.expires = jiffies + timeout;
   
5.                 add_timer(&this_drv_timer);

复制代码

每次timer_handler执行，就会再启动这个timer，

1. static void timer_handler(unsigned long arg)
   
2. {
   
3.         init_timer(&this_drv_timer);
   
4.         this_drv_timer.function = timer_handler;
   
5.         this_drv_timer.expires = jiffies + timeout;
   
6.         add_timer(&this_drv_timer);
   
7.         {
   
8.                 mm_segment_t old_fs;
   
9.                 struct file* filp = NULL;
   
10.                 char value_str[5];
    
11. 
    
12.                 old_fs = get_fs();
    
13.                 set_fs(KERNEL_DS);
    
14. 
    
15.                 filp = filp_open("/sys/class/gpio/gpio44/value",O_WRONLY,0);
    
16.                 sprintf(value_str, "%d", this_pin_v);
    
17.                 this_pin_v ^= 1;
    
18.                 filp->f_op->write(filp, value_str, 2, &filp->f_pos);
    
19.                 filp_close(filp, NULL);
    
20. 
    
21.                 set_fs(old_fs);
    
22.         }

复制代码

这里楼主并没有实验太多的代码，基本是一次成型，只不过编码途中遇到一些需要说明的事情


首先，操作相关的文件，好像不允许是用库函数fopen以及相关函数了，而是要用filp_open及相关方法。（表问我为什么，我只是跟着学）
其次，操作文件时候，要搞一下get_fs和set_fs。（表问我为什么，我只是个初学者）
再次，操作timer，每次timer到时都会把自己撤下来，所以要在定时函数中重新启动timer以实现定周期。（表问我为什么，我只是抄的代码）
还有，timer是不精确的，所以有时候LED闪动并不均匀，而且会有明显的不适。（表问我为什么，timer不是我做的）
再有，还记得aoti吗，它和fopen一样也是不允许使用的，所以看到我用了simple_strtoul。（表问我为什么，但是我确实隐隐觉得atoi也不能用）
最后，不知道出于什么原因你能看到这里，我很感激，谢谢你，祝福你，May the force be with you。以下是我的整个源码文件。结果不重要，过程才重要。

1. /* hello.c -- sjtitr */
   
2. 
   
3. #include <linux/init.h>
   
4. #include <linux/module.h>
   
5. #include <linux/moduleparam.h>
   
6. 
   
7. #include <linux/kernel.h>  
   
8. #include <linux/init.h>  
   
9. #include <linux/platform_device.h>  
   
10. 
    
11. #include <asm/uaccess.h>
    
12. #include <linux/kdev_t.h>
    
13. #include <linux/fs.h>
    
14. 
    
15. #include <linux/cdev.h>
    
16. #include <linux/device.h>
    
17. #include <linux/timer.h>
    
18. 
    
19. #define THIS_DRV_NAME        "PracticeDriver"
    
20. 
    
21. 
    
22. /* ------------------------- fileops --------------------------------- */
    
23. #define FIXED_FILE_SIZE        20
    
24. 
    
25. int practice_open(struct inode *inode, struct file *filp);
    
26. int practice_release(struct inode *inode, struct file *filp);
    
27. ssize_t practice_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos);
    
28. ssize_t practice_write(struct file *filp, const char __user *buffer, size_t count, loff_t *ppos);
    
29. 
    
30. unsigned char vt_file[FIXED_FILE_SIZE];
    
31. unsigned char vt_file_i = 0;
    
32. 
    
33. static unsigned int timeout;
    
34. 
    
35. 
    
36. 
    
37. int practice_open(struct inode *inode, struct file *filp)
    
38. {
    
39.         printk(KERN_ERR "FOPS - Open\n");
    
40.         return 0;
    
41. }
    
42. 
    
43. int practice_release(struct inode *inode, struct file *filp)
    
44. {
    
45.         printk(KERN_ERR "FOPS - Release\n");
    
46.         return 0;
    
47. }
    
48. 
    
49. ssize_t practice_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos)
    
50. {
    
51.         ssize_t size = (count < FIXED_FILE_SIZE) ? count : FIXED_FILE_SIZE;
    
52.         copy_to_user(buffer, vt_file, size);
    
53.         printk(KERN_ERR "FOPS - Read %d bytes\n", size);
    
54.         return size;
    
55. }
    
56. 
    
57. ssize_t practice_write(struct file *filp, const char __user *buffer, size_t count, loff_t *ppos)
    
58. {
    
59.         ssize_t size = (count < FIXED_FILE_SIZE) ? count : FIXED_FILE_SIZE;
    
60.         char *after;
    
61.         copy_from_user(vt_file, buffer, size);
    
62.         timeout = simple_strtoul(vt_file, &after, 10) / 2;
    
63.         printk(KERN_ERR "FOPS - Write %d\n", timeout);
    
64.         return size;
    
65. }
    
66. 
    
67. 
    
68. 
    
69. /* ------------------------- Driver ---------------------------------- */
    
70. 
    
71. 
    
72. static struct file_operations this_drv_fops =
    
73. {
    
74.         .owner                = THIS_MODULE,
    
75.         .open                = practice_open,
    
76.         .release        = practice_release,
    
77.         .read                = practice_read,
    
78.         .write                = practice_write,
    
79. };
    
80. 
    
81. static unsigned int this_dev_t;
    
82. static struct class *this_class;
    
83. 
    
84. static struct timer_list this_drv_timer;
    
85. static unsigned char this_pin_v;
    
86. 
    
87. 
    
88. static void timer_handler(unsigned long arg)
    
89. {
    
90.         init_timer(&this_drv_timer);
    
91.         this_drv_timer.function = timer_handler;
    
92.         this_drv_timer.expires = jiffies + timeout;
    
93.         add_timer(&this_drv_timer);
    
94.         {
    
95.                 mm_segment_t old_fs;
    
96.                 struct file* filp = NULL;
    
97.                 char value_str[5];
    
98. 
    
99.                 old_fs = get_fs();
    
100.                 set_fs(KERNEL_DS);
     
101. 
     
102.                 filp = filp_open("/sys/class/gpio/gpio44/value",O_WRONLY,0);
     
103.                 sprintf(value_str, "%d", this_pin_v);
     
104.                 this_pin_v ^= 1;
     
105.                 filp->f_op->write(filp, value_str, 2, &filp->f_pos);
     
106.                 filp_close(filp, NULL);
     
107. 
     
108.                 set_fs(old_fs);
     
109.         }
     
110. }
     
111. 
     
112. 
     
113. /* ------------------------- Module ---------------------------------- */
     
114. MODULE_AUTHOR("sjtitr");
     
115. MODULE_LICENSE("Dual BSD/GPL");
     
116. 
     
117. static int hello_init(void)
     
118. {
     
119.         int ret = 0;       
     
120.         int major;
     
121.        
     
122.         printk(KERN_ALERT "Hello!\n");
     
123. 
     
124.         if(!ret && (major = register_chrdev(0, THIS_DRV_NAME, &this_drv_fops))<0)  
     
125.         {  
     
126.                 printk("Failed to register chrdev\n");  
     
127.                 ret = 1;  
     
128.         }
     
129. 
     
130.         if(!ret)
     
131.         {
     
132.                 this_dev_t = MKDEV(major, 0);
     
133. 
     
134.                 printk(KERN_ERR "make driver fs\n");
     
135. 
     
136.                 this_class = class_create(THIS_MODULE,THIS_DRV_NAME);
     
137.                 if (IS_ERR(this_class))
     
138.                 {
     
139.                         printk(KERN_ERR "Failed to make driver fs\n");
     
140.                         unregister_chrdev(MAJOR(this_dev_t), THIS_DRV_NAME);
     
141.                         ret = 1;
     
142.                 }
     
143.                 else
     
144.                 {
     
145.                         device_create(this_class, NULL, this_dev_t, NULL, THIS_DRV_NAME"%d", 0);
     
146.                 }
     
147.         }
     
148. 
     
149.         if(!ret)
     
150.         {
     
151.                 mm_segment_t old_fs;
     
152.                 struct file* filp = NULL;
     
153.                 char value_str[5];
     
154. 
     
155.                 old_fs = get_fs();
     
156.                 set_fs(KERNEL_DS);
     
157. 
     
158.                 filp = filp_open("/sys/class/gpio/export",O_WRONLY,0);
     
159.                 filp->f_op->write(filp, "44", 3, &filp->f_pos);
     
160.                 filp_close(filp, NULL);
     
161.                 filp = filp_open("/sys/class/gpio/gpio44/direction",O_WRONLY,0);
     
162.                 filp->f_op->write(filp, "out", 4, &filp->f_pos);
     
163.                 filp_close(filp, NULL);
     
164.                 filp = filp_open("/sys/class/gpio/gpio44/value",O_WRONLY,0);
     
165.                 sprintf(value_str, "%d", this_pin_v);
     
166.                 this_pin_v ^= 1;
     
167.                 filp->f_op->write(filp, value_str, 2, &filp->f_pos);
     
168.                 filp_close(filp, NULL);
     
169. 
     
170.                 set_fs(old_fs);
     
171. 
     
172.                 timeout = HZ / 2;
     
173.                 init_timer(&this_drv_timer);
     
174.                 this_drv_timer.function = timer_handler;
     
175.                 this_drv_timer.expires = jiffies + timeout;
     
176.                 add_timer(&this_drv_timer);
     
177.         }
     
178.             return 0;  
     
179. }
     
180. 
     
181. static void hello_exit(void)
     
182. {
     
183.         mm_segment_t old_fs;
     
184.         struct file* filp = NULL;
     
185. 
     
186.         old_fs = get_fs();
     
187.         set_fs(KERNEL_DS);
     
188. 
     
189.         filp = filp_open("/sys/class/gpio/unexport",O_WRONLY,0);
     
190.         filp->f_op->write(filp, "44", 3, &filp->f_pos);
     
191.         filp_close(filp, NULL);
     
192. 
     
193.         set_fs(old_fs);
     
194. 
     
195.         device_destroy(this_class, this_dev_t);
     
196.         class_destroy(this_class);
     
197.         unregister_chrdev(MAJOR(this_dev_t), THIS_DRV_NAME);  
     
198.         printk(KERN_ALERT "Goodbye!\n");
     
199. }
     
200. 
     
201. module_init(hello_init);
     
202. module_exit(hello_exit);
     

复制代码

sjtitr

最近这代码提交问题很大呀，怎么头文件包含变成了那样？上次也是。

lonerzf

哈哈，太感谢楼主了。谢谢分享~ 不过论坛的代码编辑功能确实有待改善啊。

eric_wang

lonerzf 发表于 2014-4-28 10:23
哈哈，太感谢楼主了。谢谢分享~ 不过论坛的代码编辑功能确实有待改善啊。

嗯，上次修正过看来争取今天能解决好

chenzhufly

这个 这个 图不是BBB哦

sjtitr

chenzhufly 发表于 2014-4-28 13:04
这个 这个 图不是BBB哦

懒了懒了，直接从一个什么pdf里截图出来，但是使用的pin口确实一样呢，这个倒是真的。

astwyg

难道linux驱动这么容易上手?早知道团一块BB了

jaccopa

嘿嘿，吸收了，赞一个

jaccopa

astwyg 发表于 2014-4-28 16:18
难道linux驱动这么容易上手?早知道团一块BB了

有必要买一块哦，我也是上个星期才买的

jaccopa

请问楼主你的头文件是空哒？

airqj

astwyg 发表于 2014-4-28 16:18
难道linux驱动这么容易上手?早知道团一块BB了

字符驱动还好说
块设备的话......

newofcortexm3

好文，要顶，向楼主的专研精神学习。

eric_wang

jaccopa 发表于 2014-4-28 17:02
请问楼主你的头文件是空哒？

那个是论坛本身上传代码的一个小bug已经修复