跳到主要内容

PWM

在本章中,我们将学习如何在 Luckfox Lume 上配置 PWM,并通过 Shell、Python 和 C 程序控制 PWM 输出。

1. PWM 子系统​

PWM(Pulse Width Modulation,脉冲宽度调制)通过周期性改变高、低电平的持续时间控制平均输出效果。Linux 通过 /sys/class/pwm/ 提供用户空间接口。

PWM 的主要参数包括:

  • 周期 period:一个完整 PWM 周期,单位为 ns。
  • 占空比 duty_cycle:高电平在周期中持续的时间,单位为 ns。
  • 极性 polarity:normal 或 inversed。
  • 使能 enable:1 启用,0 停止。

频率与周期的关系为:

frequency = 1,000,000,000 / period

2. PWM 控制(Shell)​

2.1 PWM 引脚​

将 40Pin 第28脚 PD18 配置为 PWM2 通道2,用于输出 SG90 舵机控制脉冲。

项目配置
物理引脚40Pin 第28脚
SoC 引脚PD18
引脚复用功能pwm2_2(Function 5)
控制器 / 通道pwm2 / 通道2

2.2 设备树配置​

  1. 在 SDK 中打开板级设备树:

    device/config/chips/t153/configs/luckfox_lume/linux-5.10-origin/board.dts
  2. 设置 PD18 的复用功能pwm2_2:

    &pio {
    lume_pwm2_2_pd18_active: lume-pwm2-2-pd18-active {
    pins = "PD18";
    function = "pwm2_2";
    drive-strength = <10>;
    bias-disable;
    };

    lume_pwm2_2_pd18_sleep: lume-pwm2-2-pd18-sleep {
    pins = "PD18";
    function = "gpio_in";
    bias-pull-down;
    };
    };

    &pwm2 {
    status = "okay";
    };

    &pwm2_2 {
    pinctrl-names = "active", "sleep";
    pinctrl-0 = <&lume_pwm2_2_pd18_active>;
    pinctrl-1 = <&lume_pwm2_2_pd18_sleep>;
    status = "okay";
    };
  3. 编译设备树及打包镜像:

    ./build.sh dts
    ./build.sh
    ./build.sh pack

2.3 查看 PWM 设备​

root@luckfox:~# ls -l /sys/class/pwm
total 0
lrwxrwxrwx 1 root root 0 Sep 3 07:03 pwmchip0 -> ../../devices/platform/soc@3000000/20a0000.pwmcs0/pwm/pwmchip0
lrwxrwxrwx 1 root root 0 Sep 3 07:03 pwmchip16 -> ../../devices/platform/soc@3000000/20c0000.pwm2/pwm/pwmchip16
lrwxrwxrwx 1 root root 0 Sep 3 07:03 pwmchip8 -> ../../devices/platform/soc@3000000/20b0000.pwmcs1/pwm/pwmchip8

2.4 导出 PWM 通道​

echo 2 > /sys/class/pwm/pwmchip16/export
ls /sys/class/pwm/pwmchip16/pwm2/

导出成功后,可以看到以下属性:

capture duty_cycle enable period polarity power uevent
  • period:PWM 周期,单位为 ns。
  • duty_cycle:高电平持续时间,单位为 ns,不能大于 period。
  • polarity:输出极性,可设置为 normal 或 inversed。
  • enable:写入 1 开启输出,写入 0 停止输出。

2.5 输出 50Hz、1.5ms 正脉宽​

首次导出通道后,若 enable、period 和 duty_cycle 均为0,应先设置有效周期,再设置其他属性,避免因 period=0 返回 Invalid argument:

cd /sys/class/pwm/pwmchip16/pwm2

echo 0 > enable
echo 0 > duty_cycle
echo 20000000 > period
echo normal > polarity
echo 1500000 > duty_cycle
echo 1 > enable

其中周期为 20,000,000 ns(20ms),对应 50Hz;normal 极性下,高电平时间为 1,500,000 ns(1.5ms),对应 7.5% 占空比,用于 SG90 中位控制。

配置时始终保证 duty_cycle <= period。测试结束后,停止并释放通道:

echo 0 > /sys/class/pwm/pwmchip16/pwm2/enable
echo 2 > /sys/class/pwm/pwmchip16/unexport

停止 PWM 不会切断舵机电源,测试结束后还应关闭外部供电。

3. 控制 PWM(Python 程序)​

  1. 示例程序:以1.5ms为中位,按正弦曲线在1.1~1.9ms之间改变脉宽,使舵机周期性往返摆动。

    #!/usr/bin/env python3
    import math
    import signal
    import sys
    import time
    from pathlib import Path

    PWM_CHIP = Path("/sys/class/pwm/pwmchip16")
    CHANNEL = 2
    PWM = PWM_CHIP / f"pwm{CHANNEL}"
    PERIOD_NS = 20_000_000
    CENTER_NS = 1_500_000
    RANGE_NS = 400_000
    STEPS = 200
    running = True


    def stop(signum, frame):
    global running
    running = False


    def write_value(path, value):
    with path.open("w") as file:
    file.write(str(value))


    def main():
    exported = False
    configured = False
    enabled = False
    failed = False
    signal.signal(signal.SIGINT, stop)
    signal.signal(signal.SIGTERM, stop)

    try:
    if not PWM.is_dir():
    write_value(PWM_CHIP / "export", CHANNEL)
    exported = True
    time.sleep(0.1)

    if int((PWM / "period").read_text()) > 0:
    write_value(PWM / "enable", 0)
    write_value(PWM / "duty_cycle", 0)
    write_value(PWM / "period", PERIOD_NS)
    configured = True
    write_value(PWM / "polarity", "normal")
    write_value(PWM / "duty_cycle", CENTER_NS)
    if running:
    write_value(PWM / "enable", 1)
    enabled = True
    print("PWM2: PD18 (pin 28), 50 Hz, pulse 1.1-1.9 ms",
    flush=True)
    print("Press Ctrl+C to return to center and stop.", flush=True)

    while running:
    for step in range(STEPS):
    if not running:
    break
    phase = 2.0 * math.pi * step / STEPS
    pulse_ns = int(CENTER_NS + RANGE_NS * math.sin(phase))
    write_value(PWM / "duty_cycle", pulse_ns)
    time.sleep(0.02)
    except (OSError, ValueError) as error:
    print(f"PWM error: {error}", file=sys.stderr)
    failed = True
    finally:
    if enabled and not failed:
    try:
    write_value(PWM / "duty_cycle", CENTER_NS)
    time.sleep(0.3)
    except OSError as error:
    print(f"PWM center error: {error}", file=sys.stderr)
    failed = True

    stopped = True
    if configured:
    try:
    write_value(PWM / "enable", 0)
    except OSError as error:
    print(f"PWM stop error: {error}", file=sys.stderr)
    failed = True
    stopped = False

    if exported and stopped:
    try:
    write_value(PWM_CHIP / "unexport", CHANNEL)
    except OSError as error:
    print(f"PWM unexport error: {error}", file=sys.stderr)
    failed = True

    if not failed:
    print("PWM stopped.")
    return 1 if failed else 0


    if __name__ == "__main__":
    sys.exit(main())
  2. 打开 PWM 设备:

    PWM_CHIP = Path("/sys/class/pwm/pwmchip16")
    CHANNEL = 2
    PWM = PWM_CHIP / f"pwm{CHANNEL}"

    通过 sysfs 控制通道2。若 pwm2 目录不存在,写入 export 创建;若已存在则复用。

  3. 配置并输出 PWM:

    if int((PWM / "period").read_text()) > 0:
    write_value(PWM / "enable", 0)
    write_value(PWM / "duty_cycle", 0)
    write_value(PWM / "period", PERIOD_NS)

    已有非零周期时先停用并清零旧脉宽;初始周期为0时,先设置有效周期,避免 Invalid argument。随后设置 normal 极性、1.5ms初始脉宽并使能输出。

  4. 调整占空比:

    phase = 2.0 * math.pi * step / STEPS
    pulse_ns = int(CENTER_NS + RANGE_NS * math.sin(phase))
    write_value(PWM / "duty_cycle", pulse_ns)
    time.sleep(0.02)

    周期固定20ms(50Hz),脉宽1.1~1.9ms对应5.5%~9.5%占空比。200个步进、每步约20ms,一个往返周期约4秒。

  5. 运行程序:

    python3 PWM.py

    执行结果:

4. 控制 PWM(C 程序)​

  1. 完整代码:通过 PWM sysfs 输出 50 Hz 控制信号,使舵机按正弦曲线平滑、周期性地左右往返摆动。

    #define _POSIX_C_SOURCE 200809L
    #include <errno.h>
    #include <math.h>
    #include <signal.h>
    #include <stdio.h>
    #include <time.h>
    #include <unistd.h>

    #ifndef PWM_CHIP
    #define PWM_CHIP "/sys/class/pwm/pwmchip16"
    #endif
    #define PWM_PATH PWM_CHIP "/pwm2"
    #define CHANNEL "2"
    #define PI 3.14159265358979323846
    #define PERIOD_NS 20000000U
    #define CENTER_NS 1500000U
    #define RANGE_NS 400000U
    #define STEPS 200

    static volatile sig_atomic_t running = 1;

    static void stop(int signum)
    {
    (void)signum;
    running = 0;
    }

    static void delay_ns(long ns)
    {
    struct timespec delay = { .tv_sec = 0, .tv_nsec = ns };
    while (nanosleep(&delay, &delay) < 0 && errno == EINTR) {}
    }

    static int write_value(const char *path, const char *value)
    {
    FILE *file = fopen(path, "w");
    if (!file) {
    perror(path);
    return -1;
    }
    int failed = fprintf(file, "%s", value) < 0;
    if (fflush(file) == EOF)
    failed = 1;
    if (fclose(file) == EOF)
    failed = 1;
    if (failed)
    fprintf(stderr, "PWM write failed: %s\n", path);
    return failed ? -1 : 0;
    }

    static int write_number(const char *path, unsigned int value)
    {
    char text[32];
    snprintf(text, sizeof(text), "%u", value);
    return write_value(path, text);
    }

    static int read_period(unsigned long long *period)
    {
    FILE *file = fopen(PWM_PATH "/period", "r");
    if (!file) {
    perror(PWM_PATH "/period");
    return -1;
    }
    int failed = fscanf(file, "%llu", period) != 1;
    if (fclose(file) == EOF)
    failed = 1;
    if (failed)
    fprintf(stderr, "Cannot read PWM period\n");
    return failed ? -1 : 0;
    }

    int main(void)
    {
    int exported = 0, configured = 0, enabled = 0, failed = 0;
    int stopped = 1;
    unsigned long long old_period;
    struct sigaction action = {0};
    action.sa_handler = stop;
    sigemptyset(&action.sa_mask);
    if (sigaction(SIGINT, &action, NULL) < 0 ||
    sigaction(SIGTERM, &action, NULL) < 0) {
    perror("sigaction");
    return 1;
    }

    if (access(PWM_PATH, F_OK) < 0) {
    if (write_value(PWM_CHIP "/export", CHANNEL) < 0)
    return 1;
    exported = 1;
    delay_ns(100000000L);
    }
    if (read_period(&old_period) < 0)
    goto error;
    if (old_period > 0) {
    if (write_value(PWM_PATH "/enable", "0") < 0 ||
    write_value(PWM_PATH "/duty_cycle", "0") < 0)
    goto error;
    }
    if (write_number(PWM_PATH "/period", PERIOD_NS) < 0)
    goto error;
    configured = 1;
    if (write_value(PWM_PATH "/polarity", "normal") < 0 ||
    write_number(PWM_PATH "/duty_cycle", CENTER_NS) < 0)
    goto error;
    if (running) {
    if (write_value(PWM_PATH "/enable", "1") < 0)
    goto error;
    enabled = 1;
    puts("PWM2: PD18 (pin 28), 50 Hz, pulse 1.1-1.9 ms");
    puts("Press Ctrl+C to return to center and stop.");
    fflush(stdout);
    }

    while (running) {
    for (int step = 0; step < STEPS && running; ++step) {
    double phase = 2.0 * PI * step / STEPS;
    unsigned int pulse_ns =
    (unsigned int)(CENTER_NS + RANGE_NS * sin(phase));
    if (write_number(PWM_PATH "/duty_cycle", pulse_ns) < 0)
    goto error;
    delay_ns(20000000L);
    }
    }
    goto cleanup;

    error:
    failed = 1;
    cleanup:
    if (enabled && !failed) {
    if (write_number(PWM_PATH "/duty_cycle", CENTER_NS) < 0)
    failed = 1;
    else
    delay_ns(300000000L);
    }
    if (configured && write_value(PWM_PATH "/enable", "0") < 0) {
    failed = 1;
    stopped = 0;
    }
    if (exported && stopped &&
    write_value(PWM_CHIP "/unexport", CHANNEL) < 0)
    failed = 1;
    if (!failed)
    puts("PWM stopped.");
    return failed ? 1 : 0;
    }
  2. 导出 PWM 通道:

    if (access(PWM_PATH, F_OK) < 0) {
    if (write_value(PWM_CHIP "/export", CHANNEL) < 0)
    return 1;
    exported = 1;
    delay_ns(100000000L);
    }

    PWM_CHIP 为 pwmchip16,CHANNEL 为 "2",通道路径为 pwmchip16/pwm2。导出失败立即退出,不继续配置输出。

  3. 设置周期和占空比:

    if (old_period > 0) {
    if (write_value(PWM_PATH "/enable", "0") < 0 ||
    write_value(PWM_PATH "/duty_cycle", "0") < 0)
    goto error;
    }
    if (write_number(PWM_PATH "/period", PERIOD_NS) < 0)
    goto error;

    设置20ms周期、normal 极性和1.5ms初始脉宽。

  4. 控制 PWM 输出:

    double phase = 2.0 * PI * step / STEPS;
    unsigned int pulse_ns =
    (unsigned int)(CENTER_NS + RANGE_NS * sin(phase));
    if (write_number(PWM_PATH "/duty_cycle", pulse_ns) < 0)
    goto error;
    delay_ns(20000000L);

    按正弦曲线更新1.1~1.9ms脉宽,约4秒往返一次。

  5. 取消导出 PWM 通道:

    if (exported && stopped &&
    write_value(PWM_CHIP "/unexport", CHANNEL) < 0)
    failed = 1;

    仅在停止输出成功后,释放由程序导出的通道。

  6. 交叉编译:使用 Lume SDK 的 ARM 工具链编译。

    export PATH=<Luckfox_Lume_SDK>/out/toolchain/gcc-linaro-11.3.1-2022.06-x86_64_arm-linux-gnueabihf/bin:$PATH
    arm-linux-gnueabihf-gcc -std=c11 -O2 -Wall -Wextra PWM.c -o PWM -lm