搜索
bottom↓
回复: 0

《领航者ZYNQ之嵌入式Linux开发指南_V2.0》第二十八章 Linux蜂鸣器

[复制链接]

出0入234汤圆

发表于 2022-1-21 12:37:40 | 显示全部楼层 |阅读模式
1)实验平台:正点原子领航者V2 ZYNQ开发板
2)  章节摘自【正点原子】《领航者ZYNQ之嵌入式Linux开发指南_V2.0》
3)购买链接:https://detail.tmall.com/item.htm?id=609032204975
4)全套实验源码+手册+视频下载地址:http://www.openedv.com/thread-329957-1-1.html
5)正点原子官方B站:https://space.bilibili.com/394620890
6)正点原子FPGA技术交流QQ群:90562473
1.png

2.jpg


3.png


第二十八章 Linux蜂鸣器驱动实验

       上一章实验中我们借助gpio子系统编写了LED灯驱动,领航者开发板上还有一个蜂鸣器,从软件的角度考虑,蜂鸣器驱动和LED灯驱动其实是一摸一样的,都是控制IO输出高低电平。本章我们就来学习编写蜂鸣器的Linux驱动,也算是对上一章讲解的gpio子系统的巩固。

       1.1有源蜂鸣器简介
       蜂鸣器常用于计算机、打印机、报警器、电子玩具等电子产品中,常用的蜂鸣器有两种:有源蜂鸣器和无源蜂鸣器,这里的有“源”不是电源,而是震荡源,有源蜂鸣器内部带有震荡源,所以有源蜂鸣器只要通电就会叫。无源蜂鸣器内部不带震荡源,直接用直流电是驱动不起来的,需要2K-5K的方波去驱动。领航者开发板使用的是有源蜂鸣器,因此只要给其供电就会工作,开发板所使用的有源蜂鸣器如下图所示:
第二十八章 Linux蜂鸣器驱动实验343.png

图 28.1.1 有源蜂鸣器

       有源蜂鸣器只要通电就会叫,所以我们可以做一个供电电路,这个供电电路可以由一个IO来控制其通断,一般使用三极管来搭建这个电路。为什么我们不能像控制LED灯一样,直接将GPIO接到蜂鸣器的负极,通过IO输出高低来控制蜂鸣器的通断。因为蜂鸣器工作的电流比LED灯要大,直接将蜂鸣器接到开发板的GPIO上有可能会烧毁IO,所以我们需要通过一个三极管来间接的控制蜂鸣器的通断,相当于加了一层隔离。本章我们就驱动开发板上的有源蜂鸣器,使其周期性的“滴、滴、滴…..”鸣叫。
       本节我们来看一下如果在Linux下编写蜂鸣器驱动需要做哪些工作:
       ①在设备树中创建蜂鸣器节点beeper;
       ②在蜂鸣器节点beeper中指定gpio;
       ③编写驱动程序和测试APP,和第二十七章的LED驱动程序和测试APP基本一样。
       接下来我们就根据上面这三步来编写蜂鸣器Linux驱动程序。
       1.2硬件原理图分析
       打开领航者底板原理图文件,找到蜂鸣器电路原理图,如下所示:
第二十八章 Linux蜂鸣器驱动实验842.png

图 28.2.1 蜂鸣器原理图

       图 28.2.1中通过一个NPN型的三极管S8050来驱动蜂鸣器,通过BEEP这个IO来控制三极管Q1的导通,当BEEP输出高电平的时候Q1导通,相当于蜂鸣器的负极连接到GND,蜂鸣器形成一个通路,因此蜂鸣器会鸣叫。同理,当BEEP输出低电平的时候Q1不导通,那么蜂鸣器就没有形成一个通路,因此蜂鸣器也就不会鸣叫。
       在原理图中搜索“BEEP”标号,可知BEEP连接到了ZYNQ的M14引脚,如下图所示:
第二十八章 Linux蜂鸣器驱动实验1129.png

图 28.2.2 BEEP管脚

       M14并不是MIO引脚,而是PL端的IO引脚,但是PS可以通过EMIO来连接PL端引脚,关于MIO和EMIO的详细内容请大家阅读《领航者ZYNQ之嵌入式开发指南》的第二和第三章的内容,这里就不给大家做过多的介绍。
本篇驱动开发篇使用的hdf文件对应的vivado工程,是笔者配置的,使能了EMIO,并将M14引脚绑定到了EMIO,如下所示:
第二十八章 Linux蜂鸣器驱动实验1361.png

图 28.2.3 EMIO连接G18引脚

       所以由上面可以知道,M14连接到了EMIO的第7个引脚emio[6],由于EMIO对应的GPIO起始编号是从54开始的,所以由此可知emio[6]对应的就是GPIO 60(54 + 6),关于MIO和EMIO编号的问题在《领航者ZYNQ之嵌入式开发指南》的第二和第三章有详细的说明。
所以目标很明确了,蜂鸣器就是通过GPIO 60控制的,那么在我们的驱动代码当中就是对GPIO 60进行控制从而控制蜂鸣器鸣叫和关闭。
       1.3实验程序编写
       本实验对应的例程路径为:ZYNQ开发板光盘资料(A盘)\4_SourceCode\3_Embedded_Linux\Linux驱动例程\6_beeper。
       本章也是直接在前面的实验当中进行修改。
1.3.1修改设备树文件
       打开system-top.dts文件,在根节点“/”下创建一个名为beeper的节点,节点内容如下:
  1. 示例代码 28.3.1 system-top.dts蜂鸣器节点beeper
  2. 42 beeper {
  3. 43     compatible = "alientek,beeper";
  4. 44     status = "okay";
  5. 45     default-state = "off";
  6. 46     beeper-gpio = <&gpio0 60 GPIO_ACTIVE_HIGH>;
  7. 47 };
复制代码
       第43行,设置beeper节点的compatible属性为“alientek,beeper”,我们在驱动代码中会区匹配这个属性的值。
       第45行,将default-state属性的值设置为“off”,我们在代码中会根据default-state属性的值来设置蜂鸣器的初始化状态。
       第46行,beeper-gpio属性指定所需的GPIO。
       设备树编写完成以后使用下面这条命令重新编译设备树,如下所示:
第二十八章 Linux蜂鸣器驱动实验2251.png

图 28.3.1 重新编译设备树

       将编译出来的system-top.dtb文件重命名为system.dtb,然后将system.dtb文件拷贝到开发板SD启动卡的FAT分区,替换旧的dtb文件。替换成功之后重新启动成功开发板,以后进入“/proc/device-tree”目录中查看“beeper”节点是否存在,如果存在的话就说明设备树基本修改成功(具体还要驱动验证),结果如下图所示:
第二十八章 Linux蜂鸣器驱动实验2490.png

图 28.3.2 beeper节点

1.3.2蜂鸣器驱动程序编写
       设备树准备好以后就可以编写驱动程序了,在我们的drivers目录下新建名为“6_beeper”的文件夹,然后在6_beeper文件中新建beeper.c文件,在beeper.c里面输入如下内容:
  1. 示例代码 28.3.2 beeper.c文件内容
  2.   1 /***************************************************************
  3.   2  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
  4.   3  文件名    : beeper.c
  5.   4  作者      : 邓涛
  6.   5  版本      : V1.0
  7.   6  描述      : 领航者开发板蜂鸣器驱动文件。
  8.   7  其他      : 无
  9.   8  论坛      : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
  10.   9  日志      : 初版V1.0 2019/1/30 邓涛创建
  11. 10  ***************************************************************/
  12. 11
  13. 12 #include <linux/types.h>
  14. 13 #include <linux/kernel.h>
  15. 14 #include <linux/delay.h>
  16. 15 #include <linux/ide.h>
  17. 16 #include <linux/init.h>
  18. 17 #include <linux/module.h>
  19. 18 #include <linux/errno.h>
  20. 19 #include <linux/gpio.h>
  21. 20 #include <asm/mach/map.h>
  22. 21 #include <asm/uaccess.h>
  23. 22 #include <asm/io.h>
  24. 23 #include <linux/cdev.h>
  25. 24 #include <linux/of.h>
  26. 25 #include <linux/of_address.h>
  27. 26 #include <linux/of_gpio.h>
  28. 27
  29. 28 #define BEEPER_CNT                1                        /* 设备号个数 */
  30. 29 #define BEEPER_NAME        "beeper"                /* 名字 */
  31. 30
  32. 31 /* dtsled设备结构体 */
  33. 32 struct beeper_dev {
  34. 33     dev_t devid;                        /* 设备号 */
  35. 34     struct cdev cdev;                /* cdev */
  36. 35     struct class *class;                /* 类 */
  37. 36     struct device *device;        /* 设备 */
  38. 37     int major;                                /* 主设备号 */
  39. 38     int minor;                        /* 次设备号 */
  40. 39     struct device_node *nd;        /* 设备节点 */
  41. 40     int gpio;                                /* LED所使用的GPIO编号 */
  42. 41 };
  43. 42
  44. 43 static struct beeper_dev beeper;   /* led设备 */
  45. 44
  46. 45 /*
  47. 46  * @description                        : 打开设备
  48. 47  * @param – inode                        : 传递给驱动的inode
  49. 48  * @param – filp                        : 设备文件,file结构体有个叫做private_data的成员变量
  50. 49  *                                                  一般在open的时候将private_data指向设备结构体。
  51. 50  * @return                                : 0 成功;其他 失败
  52. 51  */
  53. 52 static int beeper_open(struct inode *inode, struct file *filp)
  54. 53 {
  55. 54     return 0;
  56. 55 }
  57. 56
  58. 57 /*
  59. 58  * @description                        : 从设备读取数据
  60. 59  * @param – filp                        : 要打开的设备文件(文件描述符)
  61. 60  * @param – buf                        : 返回给用户空间的数据缓冲区
  62. 61  * @param – cnt                        : 要读取的数据长度
  63. 62  * @param – offt                        : 相对于文件首地址的偏移
  64. 63  * @return                                : 读取的字节数,如果为负值,表示读取失败
  65. 64  */
  66. 65 static ssize_t beeper_read(struct file *filp, char __user *buf,
  67. 66             size_t cnt, loff_t *offt)
  68. 67 {
  69. 68     return 0;
  70. 69 }
  71. 70
  72. 71 /*
  73. 72  * @description                        : 向设备写数据
  74. 73  * @param – filp                        : 设备文件,表示打开的文件描述符
  75. 74  * @param – buf                        : 要写给设备写入的数据
  76. 75  * @param – cnt                        : 要写入的数据长度
  77. 76  * @param – offt                        : 相对于文件首地址的偏移
  78. 77  * @return                                : 写入的字节数,如果为负值,表示写入失败
  79. 78  */
  80. 79 static ssize_t beeper_write(struct file *filp, const char __user *buf,
  81. 80             size_t cnt, loff_t *offt)
  82. 81 {
  83. 82     int ret;
  84. 83     char kern_buf[1];
  85. 84
  86. 85     ret = copy_from_user(kern_buf, buf, cnt);  // 得到应用层传递过来的数据
  87. 86     if(0 > ret) {
  88. 87         printk(KERN_ERR "kernel write failed!\r\n");
  89. 88         return -EFAULT;
  90. 89     }
  91. 90
  92. 91     if (0 == kern_buf[0])
  93. 92         gpio_set_value(beeper.gpio, 0);        // 如果传递过来的数据是0则关闭led
  94. 93     else if (1 == kern_buf[0])
  95. 94         gpio_set_value(beeper.gpio, 1);        // 如果传递过来的数据是1则点亮led
  96. 95
  97. 96     return 0;
  98. 97 }
  99. 98
  100. 99 /*
  101. 100  * @description                        : 关闭/释放设备
  102. 101  * @param – filp                        : 要关闭的设备文件(文件描述符)
  103. 102  * @return                                : 0 成功;其他 失败
  104. 103  */
  105. 104 static int beeper_release(struct inode *inode, struct file *filp)
  106. 105 {
  107. 106     return 0;
  108. 107 }
  109. 108
  110. 109 /* 设备操作函数 */
  111. 110 static struct file_operations beeper_fops = {
  112. 111     .owner   = THIS_MODULE,
  113. 112     .open    = beeper_open,
  114. 113     .read    = beeper_read,
  115. 114     .write   = beeper_write,
  116. 115     .release = beeper_release,
  117. 116 };
  118. 117
  119. 118 static int __init beeper_init(void)
  120. 119 {
  121. 120     const char *str;
  122. 121     int ret;
  123. 122
  124. 123     /* 1.获取beeper设备节点 */
  125. 124     beeper.nd = of_find_node_by_path("/beeper");
  126. 125     if(NULL == beeper.nd) {
  127. 126         printk(KERN_ERR "beeper: Failed to get beeper node\n");
  128. 127         return -EINVAL;
  129. 128     }
  130. 129
  131. 130     /* 2.读取status属性 */
  132. 131     ret = of_property_read_string(beeper.nd, "status", &str);
  133. 132     if(!ret) {
  134. 133         if (strcmp(str, "okay"))
  135. 134             return -EINVAL;
  136. 135     }
  137. 136
  138. 137     /* 2、获取compatible属性值并进行匹配 */
  139. 138     ret = of_property_read_string(beeper.nd, "compatible", &str);
  140. 139     if(0 > ret) {
  141. 140         printk(KERN_ERR "beeper: Failed to get compatible property\n");
  142. 141         return ret;
  143. 142     }
  144. 143
  145. 144     if (strcmp(str, "alientek,beeper")) {
  146. 145         printk(KERN_ERR "beeper: Compatible match failed\n");
  147. 146         return -EINVAL;
  148. 147     }
  149. 148
  150. 149     printk(KERN_INFO "beeper: device matching successful!\r\n");
  151. 150
  152. 151     /* 4.获取设备树中的beeper-gpio属性,得到蜂鸣器所使用的GPIO编号 */
  153. 152     beeper.gpio = of_get_named_gpio(beeper.nd, "beeper-gpio", 0);
  154. 153     if(!gpio_is_valid(beeper.gpio)) {
  155. 154         printk(KERN_ERR "beeper: Failed to get beeper-gpio\n");
  156. 155         return -EINVAL;
  157. 156     }
  158. 157
  159. 158     printk(KERN_INFO "beeper: beeper-gpio num = %d\r\n", beeper.gpio);
  160. 159
  161. 160     /* 5.向gpio子系统申请使用GPIO */
  162. 161     ret = gpio_request(beeper.gpio, "Beeper gpio");
  163. 162     if (ret) {
  164. 163         printk(KERN_ERR "beeper: Failed to request gpio num %d\n", beeper.gpio);
  165. 164         return ret;
  166. 165     }
  167. 166
  168. 167     /* 6.将gpio管脚设置为输出模式 */
  169. 168     gpio_direction_output(beeper.gpio, 0);
  170. 169
  171. 170     /* 7.设置蜂鸣器的初始状态 */
  172. 171     ret = of_property_read_string(beeper.nd, "default-state", &str);
  173. 172     if(!ret) {
  174. 173         if (!strcmp(str, "on"))
  175. 174             gpio_set_value(beeper.gpio, 1);
  176. 175         else
  177. 176             gpio_set_value(beeper.gpio, 0);
  178. 177     } else
  179. 178         gpio_set_value(beeper.gpio, 0);
  180. 179
  181. 180     /* 8.注册字符设备驱动 */
  182. 181      /* 创建设备号 */
  183. 182     if (beeper.major) {
  184. 183         beeper.devid = MKDEV(beeper.major, 0);
  185. 184         ret = register_chrdev_region(beeper.devid, BEEPER_CNT, BEEPER_NAME);
  186. 185         if (ret)
  187. 186             goto out1;
  188. 187     } else {
  189. 188         ret = alloc_chrdev_region(&beeper.devid, 0, BEEPER_CNT, BEEPER_NAME);
  190. 189         if (ret)
  191. 190             goto out1;
  192. 191
  193. 192         beeper.major = MAJOR(beeper.devid);
  194. 193         beeper.minor = MINOR(beeper.devid);
  195. 194     }
  196. 195
  197. 196     printk("beeper: major=%d,minor=%d\r\n", beeper.major, beeper.minor);
  198. 197
  199. 198      /* 初始化cdev */
  200. 199     beeper.cdev.owner = THIS_MODULE;
  201. 200     cdev_init(&beeper.cdev, &beeper_fops);
  202. 201
  203. 202      /* 添加一个cdev */
  204. 203     ret = cdev_add(&beeper.cdev, beeper.devid, BEEPER_CNT);
  205. 204     if (ret)
  206. 205         goto out2;
  207. 206
  208. 207      /* 创建类 */
  209. 208     beeper.class = class_create(THIS_MODULE, BEEPER_NAME);
  210. 209     if (IS_ERR(beeper.class)) {
  211. 210         ret = PTR_ERR(beeper.class);
  212. 211         goto out3;
  213. 212     }
  214. 213
  215. 214      /* 创建设备 */
  216. 215     beeper.device = device_create(beeper.class, NULL,
  217. 216                 beeper.devid, NULL, BEEPER_NAME);
  218. 217     if (IS_ERR(beeper.device)) {
  219. 218         ret = PTR_ERR(beeper.device);
  220. 219         goto out4;
  221. 220     }
  222. 221
  223. 222     return 0;
  224. 223
  225. 224 out4:
  226. 225     class_destroy(beeper.class);
  227. 226
  228. 227 out3:
  229. 228     cdev_del(&beeper.cdev);
  230. 229
  231. 230 out2:
  232. 231     unregister_chrdev_region(beeper.devid, BEEPER_CNT);
  233. 232
  234. 233 out1:
  235. 234     gpio_free(beeper.gpio);
  236. 235
  237. 236     return ret;
  238. 237 }
  239. 238
  240. 239 static void __exit beeper_exit(void)
  241. 240 {
  242. 241     /* 注销设备 */
  243. 242     device_destroy(beeper.class, beeper.devid);
  244. 243
  245. 244     /* 注销类 */
  246. 245     class_destroy(beeper.class);
  247. 246
  248. 247     /* 删除cdev */
  249. 248     cdev_del(&beeper.cdev);
  250. 249
  251. 250     /* 注销设备号 */
  252. 251     unregister_chrdev_region(beeper.devid, BEEPER_CNT);
  253. 252
  254. 253     /* 释放GPIO */
  255. 254     gpio_free(beeper.gpio);
  256. 255 }
  257. 256
  258. 257 /* 驱动模块入口和出口函数注册 */
  259. 258 module_init(beeper_init);
  260. 259 module_exit(beeper_exit);
  261. 260
  262. 261 MODULE_AUTHOR("DengTao <<a href="mailto:773904075@qq.com">773904075@qq.com</a>>");
  263. 262 MODULE_DESCRIPTION("Alientek ZYNQ GPIO Beeper Driver");
  264. 263 MODULE_LICENSE("GPL");
复制代码
       beep.c中的内容和上一章的gpioled.c中的内容基本一样,基本上就是改了下命名。
1.3.3编写测试APP
       测试APP程序直接将上一章工程目录下的ledApp.c文件拷贝到当前实验目录,将其重命名为beeperApp.c即可。
       1.4运行测试
1.4.1编译驱动程序和测试APP
       1、编译驱动程序
       编写Makefile文件,直接将上一章实验目录下的Makefile文件拷贝到本实验目录,修改Makefile文件,将obj-m变量的值改为beeper.o,修改完成之后Makefile内容如下所示:
  1. 示例代码 28.4.1 Makefile文件内容
  2.   1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
  3.   2
  4.   3 obj-m := beeper.o
  5.   4
  6.   5 all:
  7.   6         make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
  8.   7
  9.   8 clean:
  10.   9         make -C $(KERN_DIR) M=`pwd` clean
复制代码
       第3行,设置obj-m变量的值为beeper.o。
       修改完成之后保存退出,输入如下命令编译出驱动模块文件:
  1. make
复制代码
      编译成功以后就会生成一个名为“beeper.ko”的驱动模块文件。
      2、编译测试APP
      输入如下命令编译测试beeperApp.c这个测试程序:
  1. arm-linux-gnueabihf-gcc beeperApp.c -o beeperApp
复制代码
      编译成功以后就会生成beeperApp这个应用程序,最终在本章实验实验目录下有如下文件:
第二十八章 Linux蜂鸣器驱动实验11006.png

图 28.4.1 本章实验目录下的文件

1.4.2运行测试
       将上一小节编译出来的beeper.ko和beeperApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,然后重启开发板,进入到目录/lib/modules/4.14.0-xilinx目录,输入如下命令加载beeper.ko驱动模块:
  1. depmod                                //第一次加载驱动的时候需要运行此命令
  2. modprobe beep.ko                //加载驱动
复制代码
       驱动加载成功以后会在终端中输出一些信息,如下图所示:
第二十八章 Linux蜂鸣器驱动实验11298.png

图 28.4.2 加载beeper.ko驱动模块

       从图 28.4.2中可以看出,在内核驱动中获取到的GPIO0_60的编号为963,使用beeperApp软件来测试驱动是否工作正常,输入如下命令打开蜂鸣器:
  1. ./beeperApp /dev/beeper 1                //打开蜂鸣器
复制代码
       执行上述命令之后,开发板的蜂鸣器是会鸣叫的,如果鸣叫的话说明驱动工作正常。在输入如下命令关闭蜂鸣器:
  1. ./beeperApp /dev/beeper 0                //关闭蜂鸣器
复制代码
       执行上述命令后,开发板的蜂鸣器会停止鸣叫。如果要卸载驱动的话输入如下命令即可:
  1. rmmod beep.ko
复制代码

回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子论坛 ( 公安交互式论坛备案:44190002001997 粤ICP备09047143号 )

GMT+8, 2022-8-8 21:13

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表