• PWM控制小灯泡明暗

    一.什么是pwm？

    PWM一般指脉冲宽度调制。

    PWM是Pulse Width Modulation 的缩写，中文意思就是脉冲宽度调制，简称脉宽调制。它是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术，其控制简单、灵活和动态响应好等优点而成为电力电子技术最广泛应用的控制方式。

    其应用领域包括测量，通信，功率控制与变换，电动机控制、伺服控制、调光、开关电源，甚至某些音频放大器，因此学习PWM具有十分重要的现实意义。

    二.pwm驱动蜂鸣器的原理

    蜂鸣器的发声原理由振动装置和谐振装置组成，而蜂鸣器又分为无源他激型与有源自激型，蜂鸣器的发声原理为：

    1、无源他激型蜂鸣器的工作发声原理是：方波信号输入谐振装置转换为声音信号输出。

    2、有源自激型蜂鸣器的工作发声原理是：直流电源输入经过振荡系统的放大取样电路在谐振装置作用下产生声音信号。

    有源蜂鸣器和无源蜂鸣器的主要差别是：二者对输入信号的要求不一样，有源蜂鸣器工作的理想信号是直流电，一般标示为VDD、VDC等。因为蜂鸣器内部有一个简单的振荡电路，可以把恒定的直流电转变成一定频率的脉冲信号，从而产生磁场交变，带动钼片振动发出声音。

     电路图原理：

    1、该BUZZER是无源蜂鸣器,如果要想发出声音，需要正负极产生电流变化，我们通过生成方波，从而实现图中三极管1->2周期性导通和关闭来让BUZZER俩边电压产生变化，从而实现电流变化；
    2、三极管的基极连接的是SOC的GPD0_0引脚；
    3、产生方波我们借助的是PWM，标号为MOTOR_PWM。

     pwm内部结构：​​​​​​​

     

    工作的步骤：

    1、当时钟PCLK被使能后，定时器计数缓冲寄存器（TCNTBn）把计数器初始值下载到递减计数器中。
    2、定时器比较缓冲寄存器（TCMPBn）把其初始值下载到比较寄存器中，并将该值与递减计数器的值进行比较。当递减计数器和比较寄存器值相同时，输出电平翻转。
    3、递减计数器减至0后，输出电平再次翻转，完成一个输出周期。这种基于TCNTBn和TCMPBn的双缓冲特性使定时器在频率和占空比变化时能产生稳定的输出。
    4、每个定时器都有一个专用的由定时器时钟驱动的16位递减计数器。当递减计数器的计数值达到0时，就会产生定时器中断请求来通知CPU定时器操作完成。当定时器递减计数器达到０的时候，如果设置了Auto-Reload 功能，相应的TCNTBn的值会自动重载到递减计数器中以继续下次操作。
    5、然而，如果定时器停止了，比如在定时器运行时清除TCON中定时器使能位，TCNTBn的值不会被重载到递减计数器中。
    6、TCMPBn 的值用于脉冲宽度调制。当定时器的递减计数器的值和比较寄存器的值相匹配的时候，定时器控制逻辑将改变输出电平。因此，比较寄存器决定了PWM 输出的开关时间。

    三.pwm驱动蜂鸣器的具体实现步骤 

    1.plat_fom介绍：
            从Linux2.6开始Linux加入了一套驱动管理和注册机制—platform总线驱动模型。platform总线是一条虚拟总线（只有一条），这类总线没有对应的硬件结构。platform_device为相应的设备，platform_driver为相应的驱动。与传统的bus/device/driver机制相比，platform由内核统一进行管理，提高了代码的可移植性和安全性。

    优点：

    1.可以通过platform总线，可以遍历所有的platform总线设备；platform本质其实也是kset、  kobject，具有kobject的特性;
    2.实现设备与驱动的分离，通过platform总线，设备与驱动是分开注册的，通过platform总线的  probe来随时检测与设备匹配的驱动，如匹配上即进行这个设备的驱动注册;
    3.一个驱动可以供同类的几个设备使用;

    2.设备树介绍：
              设备树是一种描述硬件得数据结构，在操作系统引导阶段进行设备初始化得时候，数据结构中得硬件信息被检测并传递给操作系统。

              Liunx内核从3.x开始引入设备树得概念，用于实现驱动代码与设备信息相分离。在设备树出现之前，所有关于设备得具体信息都要写在驱动里面，一旦外围设备变化，驱动代码就要重写。引入设备树后，驱动代码只负责处理驱动得逻辑，而关于设备具体信息要存放到设备树文件中。

              这样，如果只是硬件接口信息得变化而没有驱动逻辑得变化，驱动开发者只需要修改设备树文件信息，不需要改写驱动代码。

    驱动主体框架

    1、平台驱动架构，分为内核驱动与设备树。
        内核驱动：为固定的逻辑架构，解决向上为应用层提供调用接口，向下连接内核。
        设备树：为驱动提供设备具体参数（寄存器地址等）。
    2、写驱动就是在内核编写函数，而编写的这些函数需要具备内核调用资格，就必须符合内核的规则，所以有了“架构”的概念。随便的自定义函数可能实现不了功能甚至导致内核崩溃进而使整个操作系统崩溃。所以写内核必须按照框架写。
    3、因为编写的驱动需要符合内核的规则，就必须参考内核源码。可以借用source insight来看源码。

     平台驱动框架

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. struct of_device_id of_matches[]={
    10.                                                 //修改匹配规则，从设备树                                                                                     
    11.                                                  //获取buzzer相关硬件信息
    12. };
    13. static struct platform_driver mydriver ={
    14.                                                 //通过设备树匹配
    15.     
    16. };  
    17. static int mod_init(void)
    18. {
    19.     return  platform_driver_register(&mydriver);  //平台驱动注册
    20. }
    21. static void mod_exit(void)
    22. {
    23.     platform_driver_unregister(&mydriver);        //平台驱动注销
    24. }
    25.  
    26. module_init(mod_init);
    27. module_exit(mod_exit);
    28. MODULE_LICENSE("GPL");

    1.实现入口函数 xxx_init() 和卸载函数 xxx_exit()
    2.申请设备号 alloc_chrdev_region （与内核相关）
    3.注册字符设备驱动 cdev_alloc，cdev_init，cdev_add （与内核相关）
    4.利用 udev/mdev 机制创建设备文件（节点） class_create,device_create（与内核相关）
    5.硬件部分初始化

            从设备树获取硬件资源platform_get_resource()
            IO 资源映射 ioremap ,内核提供 gpio库函数（与硬件相关）
            注册中断（与硬件相关）
            初始化等待队列（与内核相关）
            初始化定时器（与内核相关）
    6.构建 file_operation 结构（与内核相关）
    7.实现操作硬件的方法 xxx_open，xxx_read，xxx_write…（与硬件相关）

    第一步，驱动的启动函数： 

    1. int my_probe(struct platform_device *pdev)
    2. {
    3.     int ret;
    4.     //通过设备树获取硬件资源
    5.     printk( "match\n");
    6.  
    7.     //0代表匹配的设备树第0个地址为基地址
    8.     rescon = platform_ get_ resource (pdev , IORESOURCE MEM, 0);
    9.     if ( rescon=-NULL){
    10.     goto failed_ getcon;
    11.     }
    12.     resdata = platform get_ resource (pdev , IORESOURCE MEM,1) ;
    13.     if ( resdata==NULL ){
    14.     goto failed_ getdata;
    15.     gpd0con = ioremap( rescon->start,4);
    16.     //利用设备树获取各个寄存器的地址
    17.     tcfg0 = ioremap( resdata->start,4) ;
    18.     tcfg1 = ioremap ( resdata->start+4,4) ;
    19.     tcon = ioremap( resdata->start+8,4);
    20.     tcntb0 = ioremap ( resdata->start+12,4);
    21.     tcmpb0 = ioremap( resdata->start+16,4);
    22.  
    23.     //字符设备注册
    24.     ret =  alloc_chrdev_region(&devnum,0,1,name);//1.申请设备号
    25.     if(ret!=0){
    26.         goto failed_alloc;
    27.     }
    28.     cdev_init(&mycdev,&myops); //2.cdev初始化
    29.  
    30.     ret = cdev_add(&mycdev,devnum,1); //3.cdev添加到内核
    31.     if(ret!=0){
    32.         goto failed_add;
    33.     }
    34.     printk("register success %d,%d\n",MAJOR(devnum),MINOR(devnum));
    35.  
    36.     myclass = class_create(THIS_MODULE,"myclass");
    37.     if(IS_ERR(myclass)){
    38.         goto failed_class;
    39.     }
    40.     mydevice = device_create(myclass,NULL,devnum,NULL,"buzzer");
    41.     if(IS_ERR(mydevice)){
    42.         goto failed_device;
    43.     }
    44.     //硬件操作
    45.     buzzer_init();
    46.     buzzer_off();
    47.  
    48.     return 0;
    49.  
    50. failed_device:
    51.     class_destroy(myclass);
    52. failed_class:
    53.     cdev_del(&mycdev);
    54. failed_add:
    55.     unregister_chrdev_region(devnum,1);
    56. failed_alloc:
    57.     return -1;
    58. }

    第二步，驱动卸载

    1. int my_remove(struct platform_device *pdev)
    2. {
    3.     printk("driver remove\n");
    4.     iounmap(gpd0con);
    5.     iounmap(tcfg0);
    6.     iounmap(tcfg1);
    7.     iounmap(tcon);
    8.     iounmap(tcntb0);
    9.     iounmap(tcmpb0);
    10.  
    11.     device_destroy(myclass,devnum);
    12.     class_destroy(myclass);
    13.     cdev_del(&mycdev);
    14.     unregister_chrdev_region(devnum,1);
    15.  
    16.     return 0;
    17. }

     具体实验步骤：

    1、编译生成 driver.ko 目标文件

    2、insmod driver.ko 加载驱动  

    3、编译应用层文件  

    4、运行应用层文件。
    整体代码

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. ​
    9. #define BUZZER_ON  _IO('B',1)
    10. #define BUZZER_OFF _IO('B',2)
    11. ​
    12. ​
    13. long myioctl (struct file *pf, unsigned int cmd, unsigned long arg); 
    14. int my_remove (struct platform_device  *pev);
    15. int my_probe (struct platform_device  *pev);
    16. int get_buzzer_adress(void);//获取蜂鸣器寄存器地址
    17.  int buzzer_init(void);//蜂鸣器初始化
    18. ​
    19. ​
    20. static dev_t devnum;  //设备号
    21. static struct class* myclass; 
    22. static char *name ="mydev";
    23. static int ret;
    24. struct cdev mycdev; //字符设备结构体
    25. struct device* mydevice; 
    26. struct resource *gpio1 =NULL;
    27. struct resource *gpio2 =NULL;
    28. ​
    29. static unsigned int * gpd0;//设备树第一个地址，蜂鸣器起始地址gdp_con
    30. static unsigned int * gpdx;//设备树第二个地址，pwd起始地址gdpx_fg0
    31. static unsigned int * gdpx_fg1;//二级分频
    32. static unsigned int * gdpx_fcon;//pwd控制器
    33. static unsigned int * gdpx_tb0;//设置最大值
    34. static unsigned int * gdpx_tb1;//设置最小值
    35. ​
    36. ​
    37. //定义platform_driver对象
    38. struct of_device_id of_matches[]={
    39.     {.compatible="fs,mybee"},            
    40.     {}, 
    41. };
    42. ​
    43. struct file_operations myops={
    44.     .unlocked_ioctl = myioctl,
    45. }; //字符设备集（驱动具体功能实现）
    46. struct platform_driver mydriver ={
    47.     .probe  =  my_probe, //驱动注册
    48.     .remove =  my_remove, //驱动注销
    49.     .driver={
    50.         .name = "mytest",
    51.         .of_match_table =  of_matches,  //通过设备树匹配
    52.     },
    53. };
    54. ​
    55. static int mod_init(void)
    56. {
    57.      return platform_driver_register(&mydriver);//平台驱动注册
    58. }
    59. ​
    60. static void mod_exit(void)
    61. {
    62.     platform_driver_unregister(&mydriver);//平台驱动注销
    63. }
    64. ​
    65. int my_probe (struct platform_device  *pdev) //驱动注册
    66. {
    67.     printk("match success\n");
    68. ​
    69.     //获取硬件资源
    70.     gpio1 = platform_get_resource(pdev,IORESOURCE_MEM,0);//连接硬件
    71.     if(gpio1 ==NULL)
    72.     {
    73.         goto failed_gpx2con;
    74.     }
    75.     gpd0 = (int*)ioremap(gpio1->start,4); 
    76.     printk(":%#x\n",gpio1->start);
    77.     
    78.     gpio2 = platform_get_resource(pdev,IORESOURCE_MEM,1);//连接硬件
    79.     if(gpio2 ==NULL)
    80.     {
    81.         goto failed_gpx2dat;
    82.     }
    83.     gpdx = (int*)ioremap(gpio2->start,4);
    84.     printk(":%#x\n",gpio2->start);
    85. ​
    86.     
    87. ​
    88. ​
    89.     //字符设备的注册
    90.         ret = alloc_chrdev_region(&devnum,0,1,name); //申请设备号
    91.         if(ret !=0)
    92.        goto failed_alloc;
    93. ​
    94.         cdev_init(&mycdev,&myops); //初始化设备
    95.         ret =cdev_add(&mycdev,devnum,1);//设备加入内核
    96.         if(ret !=0)
    97.         {
    98.             goto failed_add ;  
    99.         }
    100.         
    101.         printk("%d  %d\n",MAJOR(ret),MINOR(ret));
    102. ​
    103.         //自动创建设备文件
    104.         myclass =class_create(THIS_MODULE,"myclass"); // /sys/class 中创建一个类，方便管理
    105.         if(IS_ERR(myclass))
    106.         {
    107.             goto failed_class;
    108.         }
    109.         mydevice= device_create(myclass,NULL,devnum,NULL,"buzzer"); //自动创建设备文件“myled”
    110.         if(IS_ERR(mydevice))
    111.         {
    112.              goto  failed_device;
    113.         }
    114.         get_buzzer_adress();//获取蜂鸣器寄存器地址
    115.       
    116.         buzzer_init();//蜂鸣器初始化
    117.       
    118. ​
    119. return 0;
    120. //失败资源回收
    121. failed_device:
    122.     class_destroy(myclass);
    123. failed_class:
    124.     cdev_del(&mycdev);
    125. failed_add:
    126.     unregister_chrdev_region(devnum,1);
    127. failed_alloc:
    128.     iounmap(gpd0);
    129. failed_gpx2dat:
    130.     iounmap(gpdx);
    131. failed_gpx2con:
    132. return -1;
    133. ​
    134. }
    135. ​
    136.    int get_buzzer_adress(void)//获取蜂鸣器寄存器地址
    137.    {
    138.      gpd0 = (int*)ioremap(gpio1->start,4); 
    139.          gpdx = (int*)ioremap(gpio2->start,4);
    140.        
    141.         gdpx_fg1 = (int*)ioremap(gpio2->start+4,4);
    142.        
    143.         gdpx_fcon = (int*)ioremap(gpio2->start+8,4);
    144. ​
    145.         gdpx_tb0 = (int*)ioremap(gpio2->start+12,4);
    146. ​
    147.          gdpx_tb1 = (int*)ioremap(gpio2->start+16,4);
    148. ​
    149.     return 0;
    150.    }
    151.    
    152.  int buzzer_init(void)//蜂鸣器初始化
    153. {
    154.      u32 tmp;
    155.     printk("init\n");
    156. ​
    157.     *gpd0 &= ~0xf;
    158.     *gpd0 |= 0x2;  //设置蜂鸣器为pwm输出
    159.    *gpdx |= 0xff;//预分频
    160.     *gdpx_fg1 = (*gdpx_fg1 &(~0xf)) | 0x3;//二级分频
    161.     *gdpx_tb0 = 110;//自减初值
    162.     *gdpx_tb1 = 55;//比较值
    163.     *gdpx_fcon |= (0x1<<3); 
    164.     *gdpx_fcon |= (0x1<<1);
    165.     
    166.     //  *gdpx_fcon &= ~(0x1<<1);
    167.    tmp = readl(gdpx_fcon);
    168.    tmp &= ~(0x1<<1);
    169.    writel(tmp,gdpx_fcon);
    170.     
    171.     
    172.     return 0;
    173. }
    174. ​
    175. ​
    176. int my_remove (struct platform_device  *pdev)
    177. {
    178.     iounmap(gpd0);
    179.     iounmap(gpdx);
    180.     device_destroy(myclass,devnum);
    181.     class_destroy(myclass);
    182.     cdev_del(&mycdev);
    183.     unregister_chrdev_region(devnum,1);
    184.     printk("driver remove\n");
    185.     return 0;
    186. }
    187. ​
    188. ​
    189. long myioctl (struct file *pf, unsigned int cmd, unsigned long arg)
    190. {
    191.     switch (cmd)
    192.     {
    193.     case BUZZER_ON:
    194.         *gdpx_fcon |= (0x1<<0);
    195.        printk("o22n %d   %d\n",*gpdx,*gdpx_tb0 );
    196.        printk("o22n    %d\n",*gdpx_tb0);
    197.        printk("o22n    %d\n",*gdpx_tb0);
    198.         break;
    199.      case BUZZER_OFF:
    200.      printk("o22n %d   %d\n",*gpdx,*gdpx_tb0 );
    201.      *gdpx_fcon &= ~(0x1<<0);
    202.        printk("off22\n");
    203.         break;
    204. ​
    205.     default:
    206.         break;
    207.     }
    208. ​
    209.     return 0;
    210. }
    211. ​
    212. ​
    213. module_init(mod_init);
    214. module_exit(mod_exit);
    215. MODULE_LICENSE("GPL");
    216. ​

    应用层代码

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. ​
    9. #define BUZZER_ON  _IO('B',1)
    10. #define BUZZER_OFF _IO('B',2)
    11. ​
    12. int main(void)
    13. {
    14.     int fd; 
    15.     int ret;
    16.     fd = open("/dev/buzzer",O_RDWR);
    17.     if(fd==-1){
    18.         perror("open");
    19.         return -1; 
    20.     }   
    21.     //printf("open device success %d\n",fd);
    22. ​
    23.     while(1){
    24.         ioctl(fd,BUZZER_ON);
    25.         sleep(1);
    26.         ioctl(fd,BUZZER_OFF);
    27.         sleep(1);
    28.     }   
    29.  
    30.     close(fd);
    31. ​
    32.     return 0;
    33. }

    Makfile

    1. obj-m := driver.o ///最终生成 driver.ko
    2. driver-objs := test1.o
    3. KERNELDIR ?= /home/wjt/mytftp/kernel/linux-3.14 // 改为源码目录
    4. PWD := $(shell pwd) 
    5.  
    6. default:
    7.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules  
    8.     cp driver.ko /home/wjt/nfserver/rootfs  -rf  //拷贝目标到自定义目录
    9. ​
    10. clean:
    11.     rm  *.mod.c  *.mod.o  *.ko  *.o  .*.o.* .*.ko.*  *.order  Module.symvers .tmp_versions -rf

  • 相关阅读:
    Log4j输出格式控制--log4j的PatternLayout参数含义以及详细配置
    2021 Adversarial Attack（李宏毅
    Win11系统提示backgroundtaskhost.exe系统错误解决方法
    OpenCV-Python学习（1）—— OpenCV历史与安装
    Sentinel-流量防卫兵
    leetcode 684. 冗余连接
    [附源码]计算机毕业设计JAVA基于web旅游网站的设计与实现
    【21天算法挑战赛】排序算法——希尔排序
    什么是SSL/TLS/HTTPS，对称非对称加密+证书+CA
    红黑树（C语言实现）
  • 原文地址：https://blog.csdn.net/fuyuyf/article/details/126692934