求救：IMX6ULL的PWM应用程序

清秋枫叶

版主和各位大侠好：
     本人linux菜鸟，在根据教程学习IMX6ULL驱动编程，在学习到PWM编程时，发现教程只有驱动编程而没有对应的演示APP例程（别的例程都有驱动和对应的APP）。有没有对应的简易的APP例程？请提供，谢谢！


具体细节如下：IMX6U嵌入式linux驱动开发指南，第73章，Linux PWM驱动实验，在后面的驱动测试环节，使用的方法是：echo 50000 > /sys/class/pwm/pwmchip2/pwm0/period 设置频率，echo 10000 > /sys/class/pwm/pwmchip2/pwm0/duty_cycle设置占空比。那么，在应用程序里面，应该用什么函数呢？

shiguojie1989

我也发现这个问题，我刚刚解决了。
正点原子和野火对于这个pwm，都没有说清楚。
韦东山老师没有pwm的讲解。
我结合他们三位老师的讲解，我摸索着解决了问题：
我这是实现了两路pwm的驱动和app测试
设备树：

1. 
   
2.         fs_pwm {
   
3.                 compatible = "fsml,fs_pwm";
   
4.                 pinctrl-names = "default";
   
5.                 pinctrl-0 = <&pinctrl_fspwm>;
   
6.                 pwm_power {
   
7.                         pwm-names = "pwm_power";
   
8.                         pwms =         <&pwm1 0 50000>;
   
9.                 };
   
10.                 pwm_motor {
    
11.                         pwm-names = "pwm_motor";
    
12.                         pwms =         <&pwm2 0 50000>;
    
13.                 };
    
14. 
    
15.         };
    
16. 
    
17. 
    
18.         pinctrl_fspwm:fspwmgrp {
    
19.                 fsl,pins = <
    
20.                         MX6UL_PAD_LCD_DATA00__PWM1_OUT          0x1b0b0        /*/pwm1&motor pwm*/       
    
21.                         MX6UL_PAD_LCD_DATA01__PWM2_OUT          0x1b0b0        /*/pwm1&motor pwm*/       
    
22.                 >;

复制代码

驱动：

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/platform_device.h>
   
4. #include <linux/of_platform.h>
   
5. #include <linux/err.h>
   
6. #include <linux/pwm.h>
   
7. #include <linux/slab.h>
   
8. #include <linux/types.h>
   
9. #include <linux/seq_file.h>
   
10. #include <linux/stat.h>
    
11. #include <linux/tty.h>
    
12. #include <linux/kmod.h>
    
13. #include <linux/gfp.h>
    
14. 
    
15. struct pwm_device        *pwm_power_dev = NULL;  //定义pwm设备结构体
    
16. struct pwm_device   *pwm_motor_dev = NULL;
    
17. /*精简版 prob函数*/
    
18. 
    
19. /* 1. 确定主设备号                                                                 */
    
20. static int major = 0;
    
21. static struct class *fspwm_class;
    
22. //static struct gpio_desc *led_gpio;
    
23. 
    
24. /* 3. 实现对应的open/read/write等函数，填入file_operations结构体                   */
    
25. static ssize_t fspwm_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
    
26. {
    
27.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    
28.         return 0;
    
29. }
    
30. 
    
31. /* write(fd, &val, 1); */
    
32. static ssize_t fspwm_write (struct file *file, const char __user *buf, size_t size, loff_t *offset)
    
33. {
    
34.         int err;
    
35.     int k_buf = 0;
    
36.         short duty_ns,period;
    
37.         //struct inode *inode = file_inode(file);
    
38.         //int minor = iminor(inode);
    
39.        
    
40.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    
41.         err = copy_from_user(&k_buf, (void*)buf, sizeof(int));
    
42. 
    
43.     period = k_buf & 0xffff;
    
44.     duty_ns = (k_buf >> 16) & 0xffff;
    
45. 
    
46.         err = pwm_config(pwm_power_dev, duty_ns, period);
    
47.         err = pwm_config(pwm_motor_dev, duty_ns, period);
    
48.     printk("%s %d %d %d\r\n", __FUNCTION__, k_buf,  duty_ns, period);
    
49.        
    
50.         return 1;
    
51. }
    
52. 
    
53. static int fspwm_open (struct inode *node, struct file *file)
    
54. {
    
55.         //int minor = iminor(node);
    
56.        
    
57.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    
58.        
    
59.         return 0;
    
60. }
    
61. 
    
62. static int fspwm_close (struct inode *node, struct file *file)
    
63. {
    
64.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    
65.         return 0;
    
66. }
    
67. 
    
68. /* 定义自己的file_operations结构体                                              */
    
69. static struct file_operations fspwm_dev = {
    
70.         .owner         = THIS_MODULE,
    
71.         .open    = fspwm_open,
    
72.         .read    = fspwm_read,
    
73.         .write   = fspwm_write,
    
74.         .release = fspwm_close,
    
75. };
    
76. 
    
77. 
    
78. 
    
79. 
    
80. static int pwm_power_probe_new(struct platform_device *pdev)
    
81. {
    
82.         int ret = 0;
    
83.         struct device_node * child;
    
84.         struct device_node * child2;
    
85.         struct device *dev = &pdev->dev;
    
86.         printk("match success \n");
    
87. 
    
88.     //注册operations
    
89.     major = register_chrdev(0, "fspwm", &fspwm_dev);
    
90. 
    
91.         fspwm_class = class_create(THIS_MODULE, "fspwm_class");
    
92.         if (IS_ERR(fspwm_class)) {
    
93.                 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    
94.                 unregister_chrdev(major, "fspwm");
    
95.                 return PTR_ERR(fspwm_class);
    
96.         }
    
97. 
    
98.     device_create(fspwm_class, NULL, MKDEV(major, 0), NULL, "fspwm_%s","motor");
    
99. 
    
100.         child = of_get_next_child(dev->of_node, NULL);
     
101.     printk(""%s"'s child: "%s"\n", dev->of_node->full_name, child->full_name);
     
102.     printk("%s %s line %d\r\n"__FILE__, __FUNCTION__, __LINE__);
     
103.     if(NULL == child)
     
104.     {
     
105.         printk("of_get_next_child error\r\n");
     
106.     }
     
107.         if (child)
     
108.         {
     
109.                 pwm_power_dev = devm_of_pwm_get(dev, child, NULL);
     
110.                 if (IS_ERR(pwm_power_dev))
     
111.                 {
     
112.                         printk(KERN_ERR" pwm_power_dev,get pwm  error!!\n");
     
113.                         return -1;
     
114.                 }
     
115.         
     
116.         //pwm_motor_dev = devm_of_pwm_get(dev, chile, )
     
117.         }
     
118.         else
     
119.         {
     
120.                 printk(KERN_ERR" pwm_power_dev of_get_next_child  error!!\n");
     
121.                 return -1;
     
122.         }
     
123. 
     
124.         child2 = of_get_next_child(dev->of_node, child);
     
125.    
     
126.     printk(""%s"'s child2: "%s"\n", dev->of_node->full_name, child2->full_name);
     
127.     printk(""%s"'s child2: "%s"\n", dev->of_node->full_name, child2->full_name);
     
128.     printk(""%s"'s child2: "%s"\n", dev->of_node->full_name, child2->full_name);
     
129.     printk("%s %s line %d\r\n"__FILE__, __FUNCTION__, __LINE__);
     
130.     if(NULL == child2)
     
131.     {
     
132.         printk("of_get_next_child2 error\r\n");
     
133.     }
     
134.         if (child2)
     
135.         {
     
136.         if (IS_ERR(child2))
     
137.                 {
     
138.                         printk(KERN_ERR" of_get_next_child,child2  error!!\n");
     
139.                         return -1;
     
140.                 }
     
141. 
     
142.         printk(""%s"'s devm_of_pwm_get: "%s"\n", dev->of_node->full_name, child2->full_name);
     
143.                 pwm_motor_dev = devm_of_pwm_get(dev, child2, NULL);
     
144.         //pwm_motor_dev = devm_pwm_get(dev, child2->full_name);
     
145.                 if (IS_ERR(pwm_motor_dev))
     
146.                 {
     
147.                         printk(KERN_ERR" pwm_power_dev,get pwm  error!!\n");
     
148.                         return -1;
     
149.                 }
     
150.         }
     
151.         else
     
152.         {
     
153.                 printk(KERN_ERR" pwm_power_dev of_get_next_child  error!!\n");
     
154.                 return -1;
     
155.         }
     
156. 
     
157.     printk("set pwm_power...\r\n");
     
158. 
     
159.         /*配置频率100KHz 占空比80%*/
     
160.         ret = pwm_config(pwm_power_dev, 1000, 5000);
     
161.     printk("ret:%d\r\n", ret);
     
162.         /*反相 频率100KHz 占空比20%*/
     
163.         ret = pwm_set_polarity(pwm_power_dev, PWM_POLARITY_INVERSED);
     
164.     printk("ret:%d\r\n", ret);
     
165.         ret = pwm_enable(pwm_power_dev);
     
166.     printk("ret:%d\r\n", ret);
     
167. 
     
168.     printk("set pwm_motor...\r\n");
     
169.         /*配置频率100KHz 占空比80%*/
     
170.         ret = pwm_config(pwm_motor_dev, 1000, 5000);
     
171.     printk("ret:%d\r\n", ret);
     
172.         /*反相 频率100KHz 占空比20%*/
     
173.         ret = pwm_set_polarity(pwm_motor_dev, PWM_POLARITY_NORMAL);
     
174.     printk("ret:%d\r\n", ret);
     
175.         ret = pwm_enable(pwm_motor_dev);
     
176.     printk("ret:%d\r\n", ret);
     
177. 
     
178.         return ret;
     
179. }
     
180. 
     
181. static int pwm_power_remove(struct platform_device *pdev)
     
182. {
     
183. 
     
184.         device_destroy(fspwm_class, MKDEV(major, 0));
     
185.         class_destroy(fspwm_class);
     
186.         unregister_chrdev(major, "fspwm");
     
187.     printk("%s %s line %d\r\n"__FILE__, __FUNCTION__, __LINE__);
     
188.         return 0;
     
189. }
     
190. 
     
191. static const struct of_device_id of_pwm_leds_match[] = {
     
192.         {.compatible = "fs_pwm"},
     
193.         {},
     
194. };
     
195. 
     
196. static struct platform_driver led_pwm_driver = {
     
197.         .probe                = pwm_power_probe_new,
     
198.         .remove                = pwm_power_remove,
     
199.         .driver                = {
     
200.                 .name        = "fs_pwm",
     
201.                 .of_match_table = of_pwm_leds_match,
     
202.         },
     
203. };
     
204. 
     
205. /*
     
206. *驱动初始化函数
     
207. */
     
208. static int __init pwm_driver_init(void)
     
209. {
     
210.     printk("%s %s line %d\r\n"__FILE__, __FUNCTION__, __LINE__);
     
211.         return platform_driver_register(&led_pwm_driver);
     
212. }
     
213. 
     
214. /*
     
215. *驱动注销函数
     
216. */
     
217. static void __exit pwm_driver_exit(void)
     
218. {
     
219.         printk(KERN_ERR "%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
     
220.         /*注销平台设备*/
     
221.         platform_driver_unregister(&led_pwm_driver);
     
222. }
     
223. 
     
224. module_init(pwm_driver_init);
     
225. module_exit(pwm_driver_exit);
     
226. 
     
227. MODULE_LICENSE("GPL");
     
228. 
     
229. 
     
230. 
     
231. 
     
232. 
     
233. 
     
234. 
     
235. 
     

复制代码

APP：

1. #include "stdio.h"
   
2. #include "unistd.h"
   
3. #include "sys/types.h"
   
4. #include "sys/stat.h"
   
5. #include "fcntl.h"
   
6. #include "stdlib.h"
   
7. #include "string.h"
   
8. //#include "linux/ioctl.h"
   
9. #include "sys/ioctl.h"
   
10. 
    
11. 
    
12. int main(int argc, char *argv[])
    
13. {
    
14.     int fd = 0;
    
15.     int ret = 0;
    
16.     int data = 0;
    
17.     char *filename = NULL;
    
18.     unsigned int value = 0;
    
19.     unsigned short duty,period;
    
20.     int cmd=0;
    
21. 
    
22.     printf("\r\n\r\n\r\nargc num:%d\r\n",argc);
    
23. 
    
24.     filename = argv[1];
    
25.     duty = atoi(argv[2]);
    
26.     period = atoi(argv[3]);
    
27.     cmd = (duty << 16)+period;
    
28.     fd = open(filename, O_RDWR);
    
29.     if(0 > fd)
    
30.     {
    
31.         printf("can't open file %s\r\n", filename);
    
32.         return -1;
    
33.     }
    
34.     printf("open fsio_dev ok cmd:%d\r\n",cmd);
    
35. 
    
36.     write(fd, &cmd, sizeof(int));
    
37. 
    
38.     close(fd);
    
39.     printf("open fsio_dev ok cmd:%d,%d,%d\r\n",cmd,duty,period);
    
40.     return ret;   
    
41. }

复制代码

清秋枫叶

具体细节如下：IMX6U嵌入式linux驱动开发指南，第73章，Linux PWM驱动实验，在后面的驱动测试环节，使用的方法是：echo 50000 > /sys/class/pwm/pwmchip2/pwm0/period 设置频率，echo 10000 > /sys/class/pwm/pwmchip2/pwm0/duty_cycle设置占空比。那么，在应用程序里面，应该用什么函数呢？

日渐秃兀

帮顶  

清秋枫叶

非常感谢2楼回复，我现在试一下。

jckimi

兄弟，你要知道pwm是什么，他是干什么用的。
你没接外围设备的话，简单一点，用万用表电压档测电压，不同的duty cycle会有不同的电压输出。
如果你有示波器的话，那就更直观了。
当然，你也是可以接上外围设备的，比如pwm控制的lcd背光

jermy_z

它那个echo其实就是写数据   你正常打开 写  就好了

清秋枫叶

实际上，无论是backlight的（pwm1）还是教程PWM3，教程都有驱动。我现在卡壳地方是，是如何知道PWM设备名称，并在应用程序里面调用。
看来我得再下功夫学习一下。

清秋枫叶

非常感谢2楼回复，只是，我在测试的时候，输入：./pwmApp  /dev/pwm的时候，提示找不到这个文件（设备）
if(0 > fd)
    {
        printf("can't open file %s\r\n", filename);
        return -1;
    }

filename输入错误。  而且即使我运行  depmod  ;   modprobe  pwm.ko;  在/sys/dev/目录下也没有找到对应的设备。
请问，我的问题出在哪里？

清秋枫叶

补充一下，我把驱动文件命名为pwm.c ，应用程序命名为pwmApp.c

lz2297519360

jckimi 发表于 2021-5-18 16:26
兄弟，你要知道pwm是什么，他是干什么用的。
你没接外围设备的话，简单一点，用万用表电压档测电压，不同 ...

你好，请问你有没有遇到
                if (IS_ERR(pwm_power_dev))
                {
                        printk(KERN_ERR" pwm_power_dev,get pwm power error!!\n");
                        return -1;
                }
这一步出现错误？我在 get pwm error中间加了一个power

jzhang123

就是open，然后将export 的数据write进去；完了close