MCPWM 5.0

Cargo.toml

@@ -13,6 +13,9 @@ readme = "README.md"
 documentation = "https://esp-rs.github.io/esp-idf-hal/"
 rust-version = "1.61"
 
+[patch.crates-io]
+esp-idf-sys = { git = "https://github.com/esp-rs/esp-idf-sys", branch = "master" }
+
 [features]
 default = ["std", "alloc", "esp-idf-sys"]
 std = ["alloc", "esp-idf-sys/std", "edge-executor?/std"]

examples/mcpwm-simple.rs

@@ -0,0 +1,110 @@
+/// Simple example showing how MCPWM may be used to generate two synchronized pwm signals with varying duty.
+/// The duty on the pin4 will increase from 0% all the way up to 100% and repeat. At the same time the duty
+/// on pin 5 will go from 100% down to 0%
+///
+/// # duty = 10%
+///
+///               .                               .
+///               .                               .
+///               .------.                        .------.
+///               |      |                        |      |
+/// pin4          |      |                        |      |
+///               |      |                        |      |
+///           -----      --------------------------      --------------------------
+///               .                               .
+///               .                               .
+///               .------------------------.      .------------------------.
+///               |                        |      |                        |
+/// pin5          |                        |      |                        |
+///               |                        |      |                        |
+///           -----                        --------                        --------
+///               .                               .
+///
+///
+/// # duty = 50%
+///               .                               .
+///               .                               .
+///               .---------------.               .---------------.
+///               |               |               |               |
+/// pin4          |               |               |               |
+///               |               |               |               |
+///           -----               -----------------               -----------------
+///               .                               .
+///               .                               .
+///               .---------------.               .---------------.
+///               |               |               |               |
+/// pin5          |               |               |               |
+///               |               |               |               |
+///           -----               -----------------               -----------------
+///               .                               .
+///
+///
+/// # duty = 90%
+///               .                               .
+///               .                               .
+///               .------------------------.      .------------------------.
+///               |                        |      |                        |
+/// pin4          |                        |      |                        |
+///               |                        |      |                        |
+///           -----                        --------                        --------
+///               .                               .
+///               .                               .
+///               .------.                        .------.
+///               |      |                        |      |
+/// pin5          |      |                        |      |
+///               |      |                        |      |
+///           -----      --------------------------      --------------------------
+///               .                               .
+
+#[cfg(all(any(esp32, esp32s3), esp_idf_version_major = "5"))]
+fn main() -> anyhow::Result<()> {
+    use embedded_hal::delay::DelayUs;
+
+    use esp_idf_hal::delay::FreeRtos;
+    use esp_idf_hal::mcpwm::{OperatorConfig, Timer, TimerConfig};
+    use esp_idf_hal::prelude::Peripherals;
+
+    esp_idf_sys::link_patches();
+
+    println!("Configuring MCPWM");
+
+    let peripherals = Peripherals::take().unwrap();
+    let timer_config = TimerConfig::default().period_ticks(8_000); // 10kHz
+    let operator_config = OperatorConfig::default(peripherals.pins.gpio4, peripherals.pins.gpio5);
+    let timer = Timer::new(peripherals.mcpwm0.timer0, timer_config);
+
+    let mut timer = timer
+        .into_connection()
+        .attatch_operator0(peripherals.mcpwm0.operator0, operator_config);
+
+    // Borrow references to the contained timer and operator
+    let (timer, operator, _, _) = timer.split();
+
+    println!("Starting duty-cycle loop");
+
+    let period_ticks = timer.get_period_peak();
+
+    // TODO: Will this work as expected in UP_DOWN counter mode?
+    for duty in (0..period_ticks).step_by(10).cycle() {
+        if duty % 100 == 0 {
+            println!(
+                "cmp: {}, duty {}%",
+                duty,
+                100 * u32::from(duty) / u32::from(period_ticks)
+            );
+        }
+
+        operator.set_compare_value_x(duty)?; // In this configuration this controls the duty on pin4
+        operator.set_compare_value_y(period_ticks - duty)?; // and this controls pin5
+        FreeRtos.delay_ms(10)?;
+    }
+
+    unreachable!()
+}
+
+#[cfg(not(all(any(esp32, esp32s3), esp_idf_version_major = "5")))]
+fn main() {
+    esp_idf_sys::link_patches();
+
+    println!("Sorry MCPWM is only supported on ESP32 and ESP32-S3");
+}

src/lib.rs

@@ -42,6 +42,12 @@ pub mod ledc;
     not(feature = "riscv-ulp-hal")
 ))]
 pub mod mac;
+#[cfg(all(
+    any(esp32, esp32s3),
+    esp_idf_version_major = "5",
+    not(feature = "riscv-ulp-hal")
+))]
+pub mod mcpwm;
 #[cfg(not(feature = "riscv-ulp-hal"))]
 pub mod modem;
 pub mod peripheral;

src/mcpwm/comparator.rs

@@ -0,0 +1,127 @@
+use core::ptr;
+
+use esp_idf_sys::{
+    esp, mcpwm_cmpr_handle_t, mcpwm_comparator_config_t, mcpwm_comparator_config_t__bindgen_ty_1,
+    mcpwm_gen_compare_event_action_t, mcpwm_gen_handle_t, mcpwm_gen_t, mcpwm_new_comparator,
+    mcpwm_oper_handle_t, mcpwm_timer_direction_t_MCPWM_TIMER_DIRECTION_DOWN,
+    mcpwm_timer_direction_t_MCPWM_TIMER_DIRECTION_UP,
+};
+
+use super::generator::{CountingDirection, NoCmpMatchConfig, OnMatchCfg};
+
+trait ComparatorChannel {}
+
+pub struct CmpX;
+impl ComparatorChannel for CmpX {}
+
+pub struct CmpY;
+impl ComparatorChannel for CmpY {}
+
+pub trait OptionalCmp {
+    type OnMatchCfg: OnMatchCfg;
+    type Cfg: OptionalCmpCfg<Cmp = Self>;
+
+    fn get_comparator_mut(&mut self) -> Option<&mut Comparator>;
+}
+
+impl OptionalCmp for Comparator {
+    type OnMatchCfg = super::generator::CountingDirection;
+    type Cfg = ComparatorConfig;
+
+    fn get_comparator_mut(&mut self) -> Option<&mut Comparator> {
+        Some(self)
+    }
+}
+
+pub struct NoCmp;
+impl OptionalCmp for NoCmp {
+    type OnMatchCfg = super::generator::NoCmpMatchConfig;
+    type Cfg = NoCmpCfg;
+
+    fn get_comparator_mut(&mut self) -> Option<&mut Comparator> {
+        None
+    }
+}
+
+pub struct Comparator(pub(crate) mcpwm_cmpr_handle_t);
+
+impl Comparator {
+    pub(crate) unsafe fn configure(&mut self, gen: &mut mcpwm_gen_t, cfg: CountingDirection) {
+        extern "C" {
+            fn mcpwm_generator_set_actions_on_compare_event(
+                gen: mcpwm_gen_handle_t,
+                ev_act0: mcpwm_gen_compare_event_action_t,
+                ev_act1: mcpwm_gen_compare_event_action_t,
+                ev_act_end: mcpwm_gen_compare_event_action_t,
+            ) -> esp_idf_sys::esp_err_t;
+        }
+
+        esp!(mcpwm_generator_set_actions_on_compare_event(
+            gen,
+            mcpwm_gen_compare_event_action_t {
+                direction: mcpwm_timer_direction_t_MCPWM_TIMER_DIRECTION_UP,
+                comparator: self.0,
+                action: cfg.counting_up.into(),
+            },
+            mcpwm_gen_compare_event_action_t {
+                direction: mcpwm_timer_direction_t_MCPWM_TIMER_DIRECTION_DOWN,
+                comparator: self.0,
+                action: cfg.counting_down.into(),
+            },
+            mcpwm_gen_compare_event_action_t {
+                // <-- This marks the last argument in the variadic list
+                comparator: ptr::null_mut(),
+                ..Default::default()
+            }
+        ))
+        .unwrap();
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ComparatorConfig {
+    flags: mcpwm_comparator_config_t__bindgen_ty_1,
+}
+
+impl Default for ComparatorConfig {
+    fn default() -> Self {
+        let mut flags: mcpwm_comparator_config_t__bindgen_ty_1 = Default::default();
+        // TODO: What should be set here?
+        flags.set_update_cmp_on_tep(0);
+        flags.set_update_cmp_on_tez(1);
+        flags.set_update_cmp_on_sync(0);
+        Self { flags }
+    }
+}
+
+pub struct NoCmpCfg;
+
+pub trait OptionalCmpCfg {
+    type OnMatchCfg: OnMatchCfg;
+    type Cmp: OptionalCmp;
+    unsafe fn init(self, operator_handle: mcpwm_oper_handle_t) -> Self::Cmp;
+}
+
+impl OptionalCmpCfg for NoCmpCfg {
+    type OnMatchCfg = NoCmpMatchConfig;
+    type Cmp = NoCmp;
+
+    unsafe fn init(self, _operator_handle: mcpwm_oper_handle_t) -> NoCmp {
+        NoCmp
+    }
+}
+impl OptionalCmpCfg for ComparatorConfig {
+    type OnMatchCfg = CountingDirection;
+    type Cmp = Comparator;
+
+    unsafe fn init(self, operator_handle: mcpwm_oper_handle_t) -> Comparator {
+        let cfg = mcpwm_comparator_config_t { flags: self.flags };
+
+        let mut cmp = ptr::null_mut();
+        unsafe {
+            esp!(mcpwm_new_comparator(operator_handle, &cfg, &mut cmp)).unwrap();
+        }
+
+        Comparator(cmp)
+    }
+}