PWM驱动理论与分析

最新推荐文章于 2024-02-16 15:58:07 发布

又见南风

最新推荐文章于 2024-02-16 15:58:07 发布

阅读量466

点赞数

分类专栏： Linux驱动入门篇文章标签： linux c语言

本文链接：https://blog.csdn.net/m0_55334946/article/details/132844209

版权

Linux驱动入门篇专栏收录该内容

17 篇文章 0 订阅

订阅专栏

前言

瑞芯微 PWM 控制器驱动源码：/kernel/drivers/pwm/pwm-rockchip.c
目前主流的 pwm 设备驱动都是集成到 sysfs 文件系统中，通过 cat 和 echo 操作来控制，我接到的任务也是这样。
所以编写 pwm 设备驱动的核心就是完成 sysfs 操作集，通过 sysfs 来操作脉冲宽度。
PWM的原理是通过调整周期性波形的高电平时间宽度，从而改变有效信号的占空比，实现对设备的供电控制。
Linux内核支持PWM驱动框架，该驱动框架采用结构体数据类型对PWM控制器和PWM信号进行了抽象，提供了PWM驱动框架核心代码和sysfs接口代码。PWM驱动开发者可以方便地利用该驱动框架，添加特定PWM控制器的驱动程序，并使用sysfs接口进行功能调试。
PWM驱动框架头文件：kernel/include/linux/pwm.h
PWM驱动框架核心代码：kernel/drivers/pwm/core.c
PWM驱动框架sysfs接口代码：kernel/drivers/pwm/sysfs.c

一、PWM 驱动框架

数据结构

pwm_chip 表示一个 PWM 控制器。

struct pwm_chip {
    struct device        *dev;
    struct list_head    list;             // 链表
    const struct pwm_ops    *ops;         // PWM的操作函数
    int                    base;             // 索引号
    unsigned int        npwm;             // 一个PWM控制器下有几路PWM

    struct pwm_device    *pwms;            // PWM设备

    struct pwm_device *    (*of_xlate)(struct pwm_chip *pc,
                         const struct of_phandle_args *args);
    unsigned int        of_pwm_n_cells;   // 参数
    bool                can_sleep;        // 是否可以睡眠
    ......  
};

PWM 设备操作集

struct pwm_ops {
    int    (*request)(struct pwm_chip *chip,
 struct pwm_device *pwm);    //申请PWM设备
    void (*free)(struct pwm_chip *chip,
 struct pwm_device *pwm);      //释放PWM设备
    int    (*config)(struct pwm_chip *chip,              //PWM设备配置函数
                  struct pwm_device *pwm,
                  int duty_ns, int period_ns);
    int    (*set_polarity)(struct pwm_chip *chip,        //设置PWM输出极性
                        struct pwm_device *pwm,
                        enum pwm_polarity polarity);
    int    (*enable)(struct pwm_chip *chip,
 struct pwm_device *pwm);    //PWM开启
    void (*disable)(struct pwm_chip *chip,
 struct pwm_device *pwm);  //PWM关闭
#ifdef CONFIG_DEBUG_FS
    void (*dbg_show)(struct pwm_chip *chip,
 struct seq_file *s);     //开启DEBUG_FS的时候用到
#endif
    struct module *owner;
};

struct pwm_ops结构体，包括PWM控制器的操作函数。其中应该由驱动开发者实现的2个基础函数为apply函数和get_state函数；apply函数用于配置PWM控制器，包括配置PWM信号的使能状态、周期、占空比、极性等；get_state函数用于在注册PWM控制器时获取指定PWM通道信号的初始状态，包括使能状态、周期、占空比、极性等。
重点需要实现 config、enable 和 disable 函数，其他函数可以不实现。

struct pwm_device结构体，表示PWM控制器输出的PWM信号

struct pwm_device {
    const char *label;
    unsigned long flags;
    unsigned int hwpwm;
    unsigned int pwm;
    struct pwm_chip *chip;
    void *chip_data;
    
    struct pwm_args args;
    struct pwm_state state;
    struct pwm_state last;
};

框架核心函数

int pwmchip_add(struct pwm_chip *chip);

功能：注册一个 pwm 控制器设备

void pwmchip_remove(struct pwm_chip *chip);

功能：移除一个PWM控制器设备

PWM驱动典型实现方法

PWM驱动源文件位于./drivers/pwm路径下，需要驱动开发者添加相应的源文件即可，源文件设计可参考其他厂家的驱动代码。参考原有代码的命名风格，可以将新添加的驱动源文件命名为pwm-xx.c，将probe和remove函数分别命名为xx_pwm_probe和xx_pwm_remove，将PWM控制器结构体定义为struct xx_pwm_chip。
kernel/drivers/pwm路径下文件如下：
在这里插入图片描述

apply函数和get_state函数定义

根据PWM控制器手册，由驱动开发者定义apply函数和get_state函数。

xx_pwm_probe函数定义

xx_pwm_probe函数的实现方法为：首先对PWM控制器结构体struct xx_pwm_chip变量进行初始化，然后调用PWM驱动框架核心函数pwmchip_add注册一个新的PWM控制器设备。

xx_pwm_remove函数定义

xx_pwm_remove函数的实现方法为：调用PWM驱动框架核心函数pwmchip_remove移除一个PWM控制器设备。

客户主要 API

获取函数：

devm_pwm_get()    //从指定设备（dev）的DTS节点中，获得对应的PWM句柄
pwm_get()         //从指定设备（dev）的DTS节点中，获得对应的PWM句柄
pwm_put()         //释放 PWM 设备句柄

/* 与 pwm_get() 类似，区别是可以指定需要从中解析PWM信息的device node，而不是直接指定device指针 */
of_pwm_get()
devm_of_pwm_get()

状态函数：

pwm_init_state()     //初始化当前 PWM 设备状态
pwm_get_state()      //获取当前 PWM 设备状态
pwm_apply_state()    //应用到当前 PWM 设备状态

配置函数：

//配置 PWM 设备周期和占空比，主要是将PWM的周期和PWM的高电平时间写入寄存器
/* chip : PWM控制器
   pwm ：PWM设备
   duty_ns : 高电平的周期
   period_ns : PWM周期
*/
static inline int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns);

static inline int pwm_enable(struct pwm_device *pwm);      //开始 PWM 信号输出
static inline void pwm_disable(struct pwm_device *pwm);    //停止 PWM 信号输出

//设置pwm信号的极性，可选参数包括normal（PWM_POLARITY_NORMAL）和inversed（极性翻转，PWM_POLARITY_INVERSED）
static inline int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity);

二、实例：PWM 温控风扇驱动

风扇模块如下所示，黑线是负，红线是正，黄线是测速，蓝线是温控。
在这里插入图片描述

原理图分析

在这里插入图片描述
可以看出，通过控制 PWM_FAN 引脚的电平来控制风扇的转速。
继续在底板原理图上查找 PWM_FAN 引脚，PWM_FAN 引脚连接到核心板连接器 CON3 57 脚。

接下来我们打开核心板原理图，找到核心板连接器的 CON3 57 脚，如下：
在这里插入图片描述
继续在核心板原理图上查找 LCD1_PWREN_H_GPIO0_C5 引脚，如下图所示：

由上图可知，LCD1_PWREN_H_GPIO0_C5 有多个复用功能，可以作为
GPIO0_C5，PCIE30X2_WAKEn_M0，SPI0_MISO_M0，PWM6。
这里要将此引脚复用为 pwm 功能。

设备树

参考内核文档：kernel/Documentation/devicetree/bindings/pwm/pwm-rockchip.txt
参考内核文档：kernel/Documentation/devicetree/bindings/pwm/pwm-fan.txt

/* 增加风扇节点 */
fan: pwm-fan {
    compatible = "pwm-fan";
    cooling-min-state = <0>;               //最小条件状态
    cooling-max-state = <3>;               //最大条件状态
    #cooling-cells = <2>; 
    pwms = <&pwm6 0 10000 0>;
    cooling-levels = <100 150 200 250>;    //cooling-levels ： PWM duty周期值，0 - 255，与 thermal 的 cooling states 有关；
};

/* 在 pinctrl 节点中设置管脚复用为 PWM 功能 */
&pinctrl {
    ......
    pwm6 {
        /omit-if-no-ref/
        pwm6_pins: pwm6-pins {
            rockchip,pins =
                /* pwm6 */
                <0 RK_PC5 1 &pcfg_pull_none>;    // GPIO0_C5 管脚复用 PWM 输出
        };
    };
    ......
};

&pwm6 {
     status = "okay";    //使能 PWM6 控制器
};

/* 厂商提供的原生设备树，不能改 */
pwm6: pwm@fe6e0020 {
    compatible = "rockchip,rk3568-pwm", "rockchip,rk3328-pwm";
    reg = <0x0 0xfe6e0020 0x0 0x10>;
    #pwm-cells = <3>;
    pinctrl-names = "active";
    pinctrl-0 = <&pwm6_pins>;
    clocks = <&cru CLK_PWM1>, <&cru PCLK_PWM1>;
    clock-names = "pwm", "pclk";
    status = "disabled";
};

pwm属性的配置方法在 LCD 驱动篇章中讲过，如下：

pwms = <&pwm6 0 10000 0>;

&pwm6，对DTS中 pwm 节点的引用；
0，pwm device的设备号，具体需要参考SOC以及pwm driver的实际情况；
10000，PWM信号默认的周期，单位是纳秒（ns）；
PWM_POLARITY_INVERTED，可选字段，是否提供由pwm
driver决定，表示pwm信号的极性，若为0，则正常极性，若为PWM_POLARITY_INVERTED，则反转极性。

编写驱动

数据结构

#define MAX_PWM 255

struct pwm_fan_ctx {
    struct mutex lock;
    struct pwm_device *pwm;                  // PWM 设备
    unsigned int pwm_value;                  // PWM 的具体值（0~255）
    unsigned int pwm_fan_state;              // PWM 当前脉冲宽度的条件值
    unsigned int pwm_fan_max_state;          // PWM 脉冲宽度最大的条件值
    unsigned int *pwm_fan_cooling_levels;    // PWM duty周期值，简单点可以理解为脉冲宽度
    struct thermal_cooling_device *cdev;     // 温度模块在 dev 的目录
};

业务函数

/* 设置 PWM 的具体值 */
static int  __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
{
    unsigned long period;
    int ret = 0;
    struct pwm_state state = { };

    mutex_lock(&ctx->lock);
    if (ctx->pwm_value == pwm)
        goto exit_set_pwm_err;

    pwm_init_state(ctx->pwm, &state);        //将改状态值初始化到PWM设备
    period = ctx->pwm->args.period;          //获取周期值
    state.duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);    //DIV_ROUND_UP宏（向上取整）
    state.enabled = pwm ? true : false;

    ret = pwm_apply_state(ctx->pwm, &state);    //将状态应用到 pwm 设备
    if (!ret)
        ctx->pwm_value = pwm;
exit_set_pwm_err:
    mutex_unlock(&ctx->lock);
    return ret;
}

/* 更新风扇设备的状态值 */
static void pwm_fan_update_state(struct pwm_fan_ctx *ctx, unsigned long pwm)
{
    int i;

    for (i = 0; i < ctx->pwm_fan_max_state; ++i)
        if (pwm < ctx->pwm_fan_cooling_levels[i + 1])
            break;

    ctx->pwm_fan_state = i;
}

sysfs 操作集

/* 设置 pwm 设备的脉冲宽度 */
static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
{
    struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
    unsigned long pwm;
    int ret;
    //将字符串转换为unsigned long类型的数字，数字无效或者 pwm 数值超过最大值就报错
    if (kstrtoul(buf, 10, &pwm) || pwm > MAX_PWM)
        return -EINVAL;

    ret = __set_pwm(ctx, pwm);    //讲具体的 pwm 值设置到 pwm 设备中
    if (ret)
        return ret;

    pwm_fan_update_state(ctx, pwm);    //更新风扇设备的状态值
    return count;
}

static ssize_t show_pwm(struct device *dev,
                        struct device_attribute *attr, char *buf)
{
    struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);

    return sprintf(buf, "%u\n", ctx->pwm_value);
}

static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, 0);

static struct attribute *pwm_fan_attrs[] = {
    &sensor_dev_attr_pwm1.dev_attr.attr,
    NULL,
};

ATTRIBUTE_GROUPS(pwm_fan);

内核温度模块操作集

/* 获取 pwm 脉冲宽度最大值 */
static int pwm_fan_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state)
{
    struct pwm_fan_ctx *ctx = cdev->devdata;

    if (!ctx)
        return -EINVAL;

    *state = ctx->pwm_fan_max_state;

    return 0;
}

/* 获取当前 pwm 脉冲宽度的值 */
static int pwm_fan_get_cur_state(struct thermal_cooling_device *cdev,
                 unsigned long *state)
{
    struct pwm_fan_ctx *ctx = cdev->devdata;

    if (!ctx)
        return -EINVAL;

    *state = ctx->pwm_fan_state;

    return 0;
}

/* 设置当前 pwm 的值 */
static int pwm_fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
{
    struct pwm_fan_ctx *ctx = cdev->devdata;
    int ret;

    if (!ctx || (state > ctx->pwm_fan_max_state))
        return -EINVAL;

    if (state == ctx->pwm_fan_state)
        return 0;

    ret = __set_pwm(ctx, ctx->pwm_fan_cooling_levels[state]);
    if (ret) {
        dev_err(&cdev->device, "Cannot set pwm!\n");
        return ret;
    }

    ctx->pwm_fan_state = state;

    return ret;
}

/* thermal 使用的操作接口，对 ctx->pwm_fan_state 进行读写操作 */
static const struct thermal_cooling_device_ops pwm_fan_cooling_ops = {
    .get_max_state = pwm_fan_get_max_state,
    .get_cur_state = pwm_fan_get_cur_state,
    .set_cur_state = pwm_fan_set_cur_state,
};

温度模块操作集 pwm_fan_cooling_ops 通过 cdev 的方式注册。
参考资料：
Thermal 框架：https://blog.csdn.net/weixin_40237571/article/details/111953849
Thermal 模块：https://www.cnblogs.com/hellokitty2/p/15600099.html

获取设备树数据

static int pwm_fan_of_get_cooling_data(struct device *dev, struct pwm_fan_ctx *ctx)
{
    struct device_node *np = dev->of_node;
    int num, i, ret;

    if (!of_find_property(np, "cooling-levels", NULL))
        return 0;

    ret = of_property_count_u32_elems(np, "cooling-levels");
    if (ret <= 0) {
        dev_err(dev, "Wrong data!\n");
        return ret ? : -EINVAL;
    }

    num = ret;
    ctx->pwm_fan_cooling_levels = devm_kcalloc(dev, num, sizeof(u32),
                           GFP_KERNEL);
    if (!ctx->pwm_fan_cooling_levels)
        return -ENOMEM;

    ret = of_property_read_u32_array(np, "cooling-levels",
                     ctx->pwm_fan_cooling_levels, num);
    if (ret) {
        dev_err(dev, "Property 'cooling-levels' cannot be read!\n");
        return ret;
    }

    for (i = 0; i < num; i++) {
        if (ctx->pwm_fan_cooling_levels[i] > MAX_PWM) {
            dev_err(dev, "PWM fan state[%d]:%d > %d\n", i,
                ctx->pwm_fan_cooling_levels[i], MAX_PWM);
            return -EINVAL;
        }
    }

    ctx->pwm_fan_max_state = num - 1;

    return 0;
}

电源管理操作集

#ifdef CONFIG_PM_SLEEP
static int pwm_fan_suspend(struct device *dev)
{
    struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
    struct pwm_args args;
    int ret;

    pwm_get_args(ctx->pwm, &args);

    if (ctx->pwm_value) {
        ret = pwm_config(ctx->pwm, 0, args.period);    //把输出占空比跳到0
        if (ret < 0)
            return ret;

        pwm_disable(ctx->pwm);    //关了
    }

    return 0;
}

static int pwm_fan_resume(struct device *dev)
{
    struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
    struct pwm_args pargs;
    unsigned long duty;
    int ret;

    if (ctx->pwm_value == 0)
        return 0;

    pwm_get_args(ctx->pwm, &pargs);
    duty = DIV_ROUND_UP_ULL(ctx->pwm_value * (pargs.period - 1), MAX_PWM);    //设置周期值和占空比，直接开满
    ret = pwm_config(ctx->pwm, duty, pargs.period);
    if (ret)
        return ret;
    return pwm_enable(ctx->pwm);    //开风扇
}
#endif

//这部分注册后交给操作系统自己去调用
static SIMPLE_DEV_PM_OPS(pwm_fan_pm, pwm_fan_suspend, pwm_fan_resume);

probe 函数

static int pwm_fan_probe(struct platform_device *pdev)
{
    struct thermal_cooling_device *cdev;
    struct pwm_fan_ctx *ctx;
    struct device *hwmon;
    int ret;
    struct pwm_state state = { };

    ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
    if (!ctx)
        return -ENOMEM;

    mutex_init(&ctx->lock);
    // 获取设备树中指定的 PWM 节点
    ctx->pwm = devm_of_pwm_get(&pdev->dev, pdev->dev.of_node, NULL);
    if (IS_ERR(ctx->pwm)) {
        ret = PTR_ERR(ctx->pwm);
        if (ret != -EPROBE_DEFER)
            dev_err(&pdev->dev, "Could not get PWM: %d\n", ret);
        return ret;
    }
   
    platform_set_drvdata(pdev, ctx);     // 设置驱动私有数据，以后可以通过 pdev 得到 ctx
    ctx->pwm_value = MAX_PWM;            // pwm 初始值，最大转速 255

    /* Set duty cycle to maximum allowed and enable PWM output */
    pwm_init_state(ctx->pwm, &state);    // 根据 pwm 设备中的 args 参数设置 pwm 中的 state
    state.duty_cycle = ctx->pwm->args.period - 1;    // state 指向的是 pwm->state
    state.enabled = true;

    // 此函数会调用 pwm 的 apply函数， 进行寄存器配置，配置周期频率等
    ret = pwm_apply_state(ctx->pwm, &state);    
    if (ret) {
        dev_err(&pdev->dev, "Failed to configure PWM\n");
        return ret;
    }
    // 注册 hwmon 设备，会在文件系统中 /sys/class/hwmon/  生成文件 
    hwmon = devm_hwmon_device_register_with_groups(&pdev->dev, "pwmfan", ctx, pwm_fan_groups);
    if (IS_ERR(hwmon)) {
        dev_err(&pdev->dev, "Failed to register hwmon device\n");
        ret = PTR_ERR(hwmon);
        goto err_pwm_disable;
    }
    // 获取设备树中指定的 cooling-levels
    ret = pwm_fan_of_get_cooling_data(&pdev->dev, ctx);
    if (ret)
        goto err_pwm_disable;
  
    ctx->pwm_fan_state = ctx->pwm_fan_max_state;    // 设置风扇为最大状态
    if (IS_ENABLED(CONFIG_THERMAL)) {
         // 注册风扇为 cooling device，后面可以与温度传感器结合，根据具体温度设置不同的转速状态
        cdev = thermal_of_cooling_device_register(pdev->dev.of_node,
                              "pwm-fan", ctx,
                              &pwm_fan_cooling_ops);    //thermal模块集注册
        if (IS_ERR(cdev)) {
            dev_err(&pdev->dev, "Failed to register pwm-fan as cooling device");
            ret = PTR_ERR(cdev);
            goto err_pwm_disable;
        }
        ctx->cdev = cdev;
        thermal_cdev_update(cdev);    //由Governor调用进行cooling device设置，遍历 cooling 值后选择最大的设置，然后降温
    }

    printk("done success\n");
    return 0;

err_pwm_disable:
    state.enabled = false;            //关风扇
    pwm_apply_state(ctx->pwm, &state);
    return ret;
}

完善驱动注册

static int pwm_fan_remove(struct platform_device *pdev)
{
    struct pwm_fan_ctx *ctx = platform_get_drvdata(pdev);

    thermal_cooling_device_unregister(ctx->cdev);
    if (ctx->pwm_value)
        pwm_disable(ctx->pwm);
    return 0;
}

static const struct of_device_id of_pwm_fan_match[] = {
    { .compatible = "pwm-fan", },
    {},
};
MODULE_DEVICE_TABLE(of, of_pwm_fan_match);

static struct platform_driver pwm_fan_driver = {
    .probe        = pwm_fan_probe,
    .remove        = pwm_fan_remove,
    .driver    = {
        .name        = "pwm-fan",
        .pm        = &pwm_fan_pm,
        .of_match_table    = of_pwm_fan_match,
    },
};

module_platform_driver(pwm_fan_driver);

打开风扇本身只是简简单单接通电源的行为而已，通过 pwm 和温度控制主要还是为了保持主板各种芯片的正常运行，提高处理器的环境承受度上限。
例如我所在公司，客户要求设备的工作温度在 -40° ~ 80° 之间。
那么对于高温环境，就需要打开风扇来帮助主板上所有的芯片散热；低温的环境中就自动关闭风扇。
本章讲述的重点还是 pwm 驱动，前面说了，大多数 pwm 驱动的目的就为了让应用工程师在 sysfs 中操作脉冲宽度。

三、驱动添加到内核

将驱动源文件pwm-fan.c，添加到kernel/drivers/pwm路径下。
然后添加编译支持：

修改 kernel/drivers/pwm 路径下的 Makefile 文件，添加驱动选项。

# 新增gslx680驱动配置项
obj-$(CONFIG_PWM_FAN)                         += pwm_fan.o

CONFIG_PWM_FAN 是我个人写的名字，这个不限制，但是要记住这个宏，后面一直要用。
参考资料：https://blog.csdn.net/weixin_42031299/article/details/126562725

在Kbuild体系中添加配置项

# 新增 pwm_fan 驱动配置项
config CONFIG_PWM_FAN 
        tristate "Pwm Fan driver"
        depends on PWM
        help
          This enables support for PWM_FAN over pwm based.

这个主要是在查找时出现配置信息。

在kernel/drivers/pwm 目录下的 Kconfig 文件中添加上面 pwm_fan 的配置项。

注意名字要和 pwm_fan 文件夹里Makefile使用的宏

CONFIG_PWM_FAN 对应，不能出错；
config CONFIG_PWM_FAN
    bool "Rockchip PWM oneshot mode support"
    depends on PWM_ROCKCHIP
    help
      Support Rockchip pwm fan.

depends on XXX，是这个模块需要的前置选项。例如，我们使用的是瑞芯微的 PWM 控制器，所以就需要先选上瑞芯微的 PWM 控制器驱动宏 PWM_ROCKCHIP。
其他的信息随便写。

添加完成后，就可以 make menuconfig 命令来配置 pwm_fan 驱动源码。

对Kbuild体系不熟悉的可参考博客：https://blog.csdn.net/weixin_42031299/article/details/120169613
保存退出之后，输入以下命令保存配置内核文件。

make savedefconfig

重新编译内核和设备树文件。
测试：

系统启动之后，可以查看对应目录，输入以下命令：

cd /sys/class/hwmon/hwmon1/

在这里插入图片描述
可以通过下列的操作调整风扇转速，我们可以写 0~250 之间的数字到文件 /sys/class/hwmon/hwmon1/pwm1 调节转速。
我们可以输入以下命令：

echo 200 > /sys/class/hwmon/hwmon1/pwm1

通过写入不同的值观察风扇的转速，如果有条件的话可以用示波器观察 pwm
波形改变。

打开 6 号 PWM 通道信号

echo 6 > /sys/class/pwm/pwmchip0/export

设置PWM信号周期

echo pvalue > /sys/class/pwm/pwmchip0/pwm6/period

设置PWM信号占空比

echo dvalue > /sys/class/pwm/pwmchip0/pwm6/duty_cycle

使能某个PWM通道信号

echo 1 > /sys/class/pwm/pwmchip0/pwm6/enable

禁止某个PWM通道信号

echo 0 > /sys/class/pwm/pwmchip0/pwm6/enable

参考资料：
定时器中断计算转速的部分：https://blog.csdn.net/u014443578/article/details/124325602
韦东山讲 PWM 应用：https://cloud.tencent.com/developer/article/2223398
PWM 框架：https://blog.csdn.net/yangguoyu8023/article/details/122251015

又见南风

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
PWM驱动理论与分析

瑞芯微 PWM 控制器驱动源码：/kernel/drivers/pwm/pwm-rockchip.c目前主流的 pwm 设备驱动都是集成到 sysfs 文件系统中，通过 cat 和 echo 操作来控制，我接到的任务也是这样。所以编写 pwm 设备驱动的核心就是完成 sysfs 操作集，通过 sysfs 来操作脉冲宽度。PWM的原理是通过调整周期性波形的高电平时间宽度，从而改变有效信号的占空比，实现对设备的供电控制。
复制链接

扫一扫