MCPWM 外设是一个多功能 PWM 生成器，集成多个子模块，在电力电子应用（如电机控制、数字电源等）中至关重要。MCPWM 外设通常适用于以下场景：

数字电机控制，如有刷/无刷直流电机、RC 伺服电机

基于开关模式的数字电源转换

功率数模转换器 (Power DAC)，其中占空比等于 DAC 的模拟值

计算外部脉宽，并将其转换为其他模拟值，如速度、距离

为磁场定向控制 (FOC) 生成空间矢量调制 (SVPWM) 信号

本教程采用esp-idf v5.3版本，与4.4版本存在差异，旧版驱动仍然可用，其引用路径为 driver/mcpwm.h。但是，使用旧版驱动会默认触发如下编译警告，可以通过配置 Kconfig 选项 CONFIG_MCPWM_SUPPRESS_DEPRECATE_WARN 来关闭该警告。

#include “driver/mcpwm.h”

以下内容为5.3版本内容

MCPWM 定时器模块：最终输出 PWM 信号的时间基准。它也决定了其他子模块的事件时序。

MCPWM 操作器模块：生成 PWM 波形的关键模块。它由其他子模块组成，如比较器、PWM 生成器、死区生成器和载波调制器。

MCPWM 比较器模块：输入时间基准值，并不断与配置的阈值进行比较。当定时器计数值等于任何一个阈值时，生成一个比较事件，MCPWM 生成器随即相应更新其电平。

MCPWM 生成器模块：根据 MCPWM 定时器、MCPWM 比较器等子模块触发的各种事件，生成一对独立或互补的 PWM 波形。

MCPWM 故障检测模块：通过 GPIO 交换矩阵检测外部的故障情况。检测到故障信号时，MCPWM 操作器将强制所有生成器进入预先定义的状态，从而保护系统。

MCPWM 同步模块：同步 MCPWM 定时器，以确保由不同的 MCPWM 生成器最终生成的 PWM 信号具有固定的相位差。可以通过 GPIO 交换矩阵和 MCPWM 定时器事件生成同步信号。

死区生成器模块：在此前生成的 PWM 边沿上插入额外的延迟。

载波模块：可通过 PWM 波形生成器和死区生成器，将一个高频载波信号调制为 PWM 波形，这是控制功率开关器件的必需功能。

制动控制：MCPWM 操作器支持配置检测到特定故障时生成器的制动控制方式。根据故障的严重程度，可以选择立即关闭或是逐周期调节 PWM 输出。

MCPWM 捕获模块：独立子模块，不依赖于上述 MCPWM 操作器工作。捕获模块包括一个专用的定时器和几个独立的通道，每个通道都与 GPIO 相连。GPIO 上的脉冲触发捕获定时器以存储时间基准值，随后通过中断进行通知。此模块有助于更加精准地测量脉宽。此外，捕获定时器也可以通过 MCPWM 同步子模块进行同步。

1.头文件

#include "driver/mcpwm_timer.h"

#include "driver/mcpwm_oper.h"

#include "driver/mcpwm_cmpr.h"

#include "driver/mcpwm_gen.h"

#include "driver/mcpwm_fault.h"

#include "driver/mcpwm_sync.h"

#include "driver/mcpwm_cap.h"

#include "driver/mcpwm_etm.h"

2.常用配置

详细配置可以翻阅官方案例
本例程截取官方案列控制伺服电机角度

//创建定时器
 mcpwm_timer_handle_t timer = NULL;
 mcpwm_timer_config_t timer_config = {
     .group_id = 0,										//指定从哪个组分配MCPWM定时器
     .clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,			//MCPWM定时器时钟源
     .resolution_hz = SERVO_TIMEBASE_RESOLUTION_HZ,		//计数器分辨率（Hz）每个计数滴答的步长等于（1 / resolution_hz）秒
     .period_ticks = SERVO_TIMEBASE_PERIOD,				//一个周期内的计数滴答数
     .count_mode = MCPWM_TIMER_COUNT_MODE_UP,			//计数模式
 };
ESP_ERROR_CHECK(mcpwm_new_timer(&timer_config, &timer));
 
 //创建操作器
mcpwm_oper_handle_t oper = NULL;
mcpwm_operator_config_t operator_config = {
     .group_id = 0, //指定从哪个组分配MCPWM定时器
};
ESP_ERROR_CHECK(mcpwm_new_operator(&operator_config, &oper));

//连接定时器与操作器
ESP_ERROR_CHECK(mcpwm_operator_connect_timer(oper, timer));

//创建比较器和生成器，与生成器绑定
mcpwm_cmpr_handle_t comparator = NULL;
mcpwm_comparator_config_t comparator_config = {
    .flags.update_cmp_on_tez = true,		//比较器的额外配置标志
};
ESP_ERROR_CHECK(mcpwm_new_comparator(oper, &comparator_config, &comparator));
mcpwm_gen_handle_t generator = NULL;
mcpwm_generator_config_t generator_config = {
    .gen_gpio_num = SERVO_PULSE_GPIO,		//用于输出PWM信号的GPIO号
};
ESP_ERROR_CHECK(mcpwm_new_generator(oper, &generator_config, &generator));

//当计数器事件发生时，生成器将GPIO引脚设置为高电平
ESP_ERROR_CHECK(mcpwm_generator_set_action_on_timer_event(generator, MCPWM_GEN_TIMER_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH)));
//当比较事件发生时，生成器将GPIO引脚设置为低电平
ESP_ERROR_CHECK(mcpwm_generator_set_action_on_compare_event(generator, MCPWM_GEN_COMPARE_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, comparator, MCPWM_GEN_ACTION_LOW)));

//启动定时器
ESP_ERROR_CHECK(mcpwm_timer_enable(timer));
ESP_ERROR_CHECK(mcpwm_timer_start_stop(timer, MCPWM_TIMER_START_NO_STOP));

3.函数

//创建 MCPWM 定时器
esp_err_t mcpwm_new_timer(const mcpwm_timer_config_t *config, mcpwm_timer_handle_t *ret_timer);

//删除 MCPWM 定时器
esp_err_t mcpwm_del_timer(mcpwm_timer_handle_t timer);

//为 MCPWM 定时器设置新的周期
esp_err_t mcpwm_timer_set_period(mcpwm_timer_handle_t timer, uint32_t period_ticks);

//启用 MCPWM 定时器
esp_err_t mcpwm_timer_enable(mcpwm_timer_handle_t timer);

//禁用 MCPWM 定时器
esp_err_t mcpwm_timer_disable(mcpwm_timer_handle_t timer);

//向 MCPWM 定时器发送特定的启动/停止命令
esp_err_t mcpwm_timer_start_stop(mcpwm_timer_handle_t timer, mcpwm_timer_start_stop_cmd_t command);

//为 MCPWM 定时器设置事件回调
esp_err_t mcpwm_timer_register_event_callbacks(mcpwm_timer_handle_t timer, const mcpwm_timer_event_callbacks_t *cbs, void *user_data);

//设置 MCPWM 定时器的同步相位
esp_err_t mcpwm_timer_set_phase_on_sync(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_phase_config_t *config);

//创建 MCPWM 操作器
esp_err_t mcpwm_new_operator(const mcpwm_operator_config_t *config, mcpwm_oper_handle_t *ret_oper);

//删除 MCPWM 操作器
esp_err_t mcpwm_del_operator(mcpwm_oper_handle_t oper);

//将 MCPWM 操作器与定时器连接起来，使得操作器可以由定时器来驱动
esp_err_t mcpwm_operator_connect_timer(mcpwm_oper_handle_t oper, mcpwm_timer_handle_t timer);

//设置 MCPWM 操作器的制动方法
esp_err_t mcpwm_operator_set_brake_on_fault(mcpwm_oper_handle_t oper, const mcpwm_brake_config_t *config);

//尝试使操作器从故障中恢复
esp_err_t mcpwm_operator_recover_from_fault(mcpwm_oper_handle_t oper, mcpwm_fault_handle_t fault);

//为 MCPWM 操作器设置事件回调
esp_err_t mcpwm_operator_register_event_callbacks(mcpwm_oper_handle_t oper, const mcpwm_operator_event_callbacks_t *cbs, void *user_data);

//为 MCPWM 操作员应用载波特征
esp_err_t mcpwm_operator_apply_carrier(mcpwm_oper_handle_t oper, const mcpwm_carrier_config_t *config);

// 创建 MCPWM 比较器
esp_err_t mcpwm_new_comparator(mcpwm_oper_handle_t oper, const mcpwm_comparator_config_t *config, mcpwm_cmpr_handle_t *ret_cmpr);

//删除 MCPWM 比较器
esp_err_t mcpwm_del_comparator(mcpwm_cmpr_handle_t cmpr);

//为 MCPWM 比较器设置事件回调
esp_err_t mcpwm_comparator_register_event_callbacks(mcpwm_cmpr_handle_t cmpr, const mcpwm_comparator_event_callbacks_t *cbs, void *user_data);

//设置 MCPWM 比较器的比较值
esp_err_t mcpwm_comparator_set_compare_value(mcpwm_cmpr_handle_t cmpr, uint32_t cmp_ticks);

//从给定的操作员分配 MCPWM 生成器
esp_err_t mcpwm_new_generator(mcpwm_oper_handle_t oper, const mcpwm_generator_config_t *config, mcpwm_gen_handle_t *ret_gen);

//删除 MCPWM 生成器
esp_err_t mcpwm_del_generator(mcpwm_gen_handle_t gen);

//设置 MCPWM 生成器的强制级别
esp_err_t mcpwm_generator_set_force_level(mcpwm_gen_handle_t gen, int level, bool hold_on);

//设置 MCPWM 定时器事件的生成器动作
esp_err_t mcpwm_generator_set_action_on_timer_event(mcpwm_gen_handle_t gen, mcpwm_gen_timer_event_action_t ev_act);

//在多个 MCPWM 定时器事件上设置生成器操作
esp_err_t mcpwm_generator_set_actions_on_timer_event(mcpwm_gen_handle_t gen, mcpwm_gen_timer_event_action_t ev_act, ...);

//设置 MCPWM 比较事件的生成器动作
esp_err_t mcpwm_generator_set_action_on_compare_event(mcpwm_gen_handle_t generator, mcpwm_gen_compare_event_action_t ev_act);

//设置多个 MCPWM 比较事件上的生成器操作
esp_err_t mcpwm_generator_set_actions_on_compare_event(mcpwm_gen_handle_t generator, mcpwm_gen_compare_event_action_t ev_act, ...);

//设置 MCPWM 制动事件时的生成器动作
esp_err_t mcpwm_generator_set_action_on_brake_event(mcpwm_gen_handle_t generator, mcpwm_gen_brake_event_action_t ev_act);

//设置多个 MCPWM 制动事件上的生成器动作
esp_err_t mcpwm_generator_set_actions_on_brake_event(mcpwm_gen_handle_t generator, mcpwm_gen_brake_event_action_t ev_act, ...);

//设置 MCPWM 故障事件时的生成器动作
esp_err_t mcpwm_generator_set_action_on_fault_event(mcpwm_gen_handle_t generator, mcpwm_gen_fault_event_action_t ev_act);

//设置 MCPWM 同步事件上的生成器动作
esp_err_t mcpwm_generator_set_action_on_sync_event(mcpwm_gen_handle_t generator, mcpwm_gen_sync_event_action_t ev_act);

//设置 MCPWM 生成器的死区时间
esp_err_t mcpwm_generator_set_dead_time(mcpwm_gen_handle_t in_generator, mcpwm_gen_handle_t out_generator, const mcpwm_dead_time_config_t *config);

// 创建 MCPWM GPIO 故障
esp_err_t mcpwm_new_gpio_fault(const mcpwm_gpio_fault_config_t *config, mcpwm_fault_handle_t *ret_fault);

//创建 MCPWM 软件故障
esp_err_t mcpwm_new_soft_fault(const mcpwm_soft_fault_config_t *config, mcpwm_fault_handle_t *ret_fault);

// 删除 MCPWM 故障
esp_err_t mcpwm_del_fault(mcpwm_fault_handle_t fault);

//激活软件故障，触发一次故障事件
esp_err_t mcpwm_soft_fault_activate(mcpwm_fault_handle_t fault);

//设置 MCPWM 故障的事件回调
esp_err_t mcpwm_fault_register_event_callbacks(mcpwm_fault_handle_t fault, const mcpwm_fault_event_callbacks_t *cbs, void *user_data);

//创建 MCPWM 定时器同步源
esp_err_t mcpwm_new_timer_sync_src(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync);

//创建 MCPWM GPIO 同步源
esp_err_t mcpwm_new_gpio_sync_src(const mcpwm_gpio_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync);

//创建 MCPWM 软件同步源
esp_err_t mcpwm_new_soft_sync_src(const mcpwm_soft_sync_config_t *config, mcpwm_sync_handle_t *ret_sync);

//删除 MCPWM 同步源
esp_err_t mcpwm_del_sync_src(mcpwm_sync_handle_t sync);

//激活软件同步，触发一次同步事件
esp_err_t mcpwm_soft_sync_activate(mcpwm_sync_handle_t sync);

//创建 MCPWM 捕获定时器
esp_err_t mcpwm_new_capture_timer(const mcpwm_capture_timer_config_t *config, mcpwm_cap_timer_handle_t *ret_cap_timer);

//删除 MCPWM 捕获定时器
esp_err_t mcpwm_del_capture_timer(mcpwm_cap_timer_handle_t cap_timer);

//启用 MCPWM 捕获定时器
esp_err_t mcpwm_capture_timer_enable(mcpwm_cap_timer_handle_t cap_timer);

//禁用 MCPWM 捕获定时器
esp_err_t mcpwm_capture_timer_disable(mcpwm_cap_timer_handle_t cap_timer);

//启动 MCPWM 捕获定时器
esp_err_t mcpwm_capture_timer_start(mcpwm_cap_timer_handle_t cap_timer);

//停止 MCPWM 捕获定时器
esp_err_t mcpwm_capture_timer_stop(mcpwm_cap_timer_handle_t cap_timer);

//获取 MCPWM 捕获定时器分辨率，以 Hz 为单位
esp_err_t mcpwm_capture_timer_get_resolution(mcpwm_cap_timer_handle_t cap_timer, uint32_t *out_resolution);

//设置 MCPWM 捕获定时器的同步相位
esp_err_t mcpwm_capture_timer_set_phase_on_sync(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_timer_sync_phase_config_t *config);

//创建 MCPWM 捕获通道
esp_err_t mcpwm_new_capture_channel(mcpwm_cap_timer_handle_t cap_timer, const mcpwm_capture_channel_config_t *config, mcpwm_cap_channel_handle_t *ret_cap_channel);

//删除 MCPWM 捕获通道
esp_err_t mcpwm_del_capture_channel(mcpwm_cap_channel_handle_t cap_channel);

//启用 MCPWM 捕获通道
esp_err_t mcpwm_capture_channel_enable(mcpwm_cap_channel_handle_t cap_channel);

//禁用 MCPWM 捕获通道
esp_err_t mcpwm_capture_channel_disable(mcpwm_cap_channel_handle_t cap_channel);

//为 MCPWM 捕获通道设置事件回调
esp_err_t mcpwm_capture_channel_register_event_callbacks(mcpwm_cap_channel_handle_t cap_channel, const mcpwm_capture_event_callbacks_t *cbs, void *user_data);

//通过软件触发捕获
esp_err_t mcpwm_capture_channel_trigger_soft_catch(mcpwm_cap_channel_handle_t cap_channel);