From 9ac52a768bbcd4bc8b753c64805fc23906b2c91f Mon Sep 17 00:00:00 2001 From: huntc Date: Fri, 28 Jan 2022 16:21:53 +1100 Subject: [PATCH] Now permits sequences to be mutated subsequently --- embassy-nrf/src/pwm.rs | 24 +++++++---- examples/nrf/src/bin/pwm_sequence.rs | 8 ++-- examples/nrf/src/bin/pwm_sequence_ppi.rs | 4 +- examples/nrf/src/bin/pwm_sequence_ws2812b.rs | 43 ++++++++++++++++---- 4 files changed, 58 insertions(+), 21 deletions(-) diff --git a/embassy-nrf/src/pwm.rs b/embassy-nrf/src/pwm.rs index 41dcce04..94dfdeda 100644 --- a/embassy-nrf/src/pwm.rs +++ b/embassy-nrf/src/pwm.rs @@ -31,6 +31,8 @@ pub struct SequencePwm<'d, T: Instance> { ch1: Option, ch2: Option, ch3: Option, + sequence0: Option>, + sequence1: Option>, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -125,11 +127,13 @@ impl<'d, T: Instance> SequencePwm<'d, T> { ch1: ch1.degrade_optional(), ch2: ch2.degrade_optional(), ch3: ch3.degrade_optional(), + sequence0: None, + sequence1: None, }) } /// Start or restart playback. Takes at least one sequence along with its - /// configuration. Optionally takes a second sequence and/or its configuration. + /// configuration. Optionally takes a second sequence and its configuration. /// In the case where no second sequence is provided then the first sequence /// is used. The sequence mode applies to both sequences combined as one. #[inline(always)] @@ -152,7 +156,7 @@ impl<'d, T: Instance> SequencePwm<'d, T> { return Err(Error::SequenceTimesAtLeastOne); } - self.stop(); + let _ = self.stop(); let r = T::regs(); @@ -222,6 +226,9 @@ impl<'d, T: Instance> SequencePwm<'d, T> { } } + self.sequence0 = Some(sequence0); + self.sequence1 = sequence1; + Ok(()) } @@ -326,9 +333,10 @@ impl<'d, T: Instance> SequencePwm<'d, T> { } /// Stop playback. Disables the peripheral. Does NOT clear the last duty - /// cycle from the pin. + /// cycle from the pin. Returns any sequences previously provided to + /// `start` so that they may be further mutated. #[inline(always)] - pub fn stop(&self) { + pub fn stop(&mut self) -> (Option>, Option>) { let r = T::regs(); r.shorts.reset(); @@ -339,6 +347,8 @@ impl<'d, T: Instance> SequencePwm<'d, T> { r.tasks_stop.write(|w| unsafe { w.bits(0x01) }); r.enable.write(|w| w.enable().disabled()); + + (self.sequence0.take(), self.sequence1.take()) } } @@ -346,7 +356,7 @@ impl<'a, T: Instance> Drop for SequencePwm<'a, T> { fn drop(&mut self) { let r = T::regs(); - self.stop(); + let _ = self.stop(); if let Some(pin) = &self.ch0 { pin.set_low(); @@ -415,13 +425,13 @@ impl Default for SequenceConfig { #[non_exhaustive] pub struct Sequence<'d> { /// The words comprising the sequence. Must not exceed 32767 words. - pub words: &'d [u16], + pub words: &'d mut [u16], /// Configuration associated with the sequence. pub config: SequenceConfig, } impl<'d> Sequence<'d> { - pub fn new(words: &'d [u16], config: SequenceConfig) -> Self { + pub fn new(words: &'d mut [u16], config: SequenceConfig) -> Self { Self { words, config } } } diff --git a/examples/nrf/src/bin/pwm_sequence.rs b/examples/nrf/src/bin/pwm_sequence.rs index 78787d53..6fb861e8 100644 --- a/examples/nrf/src/bin/pwm_sequence.rs +++ b/examples/nrf/src/bin/pwm_sequence.rs @@ -13,8 +13,8 @@ use embassy_nrf::Peripherals; #[embassy::main] async fn main(_spawner: Spawner, p: Peripherals) { - let seq_words_1: [u16; 5] = [1000, 250, 100, 50, 0]; - let seq_words_2: [u16; 5] = [0, 50, 100, 250, 1000]; + let mut seq_words_1: [u16; 5] = [1000, 250, 100, 50, 0]; + let mut seq_words_2: [u16; 5] = [0, 50, 100, 250, 1000]; let mut config = Config::default(); config.prescaler = Prescaler::Div128; @@ -30,7 +30,7 @@ async fn main(_spawner: Spawner, p: Peripherals) { p.PWM0, p.P0_13, NoPin, NoPin, NoPin, config, )); let _ = pwm.start( - Sequence::new(&seq_words_1, seq_config.clone()), + Sequence::new(&mut seq_words_1, seq_config.clone()), None, SequenceMode::Infinite, ); @@ -41,7 +41,7 @@ async fn main(_spawner: Spawner, p: Peripherals) { info!("pwm starting with another sequence!"); let _ = pwm.start( - Sequence::new(&seq_words_2, seq_config), + Sequence::new(&mut seq_words_2, seq_config), None, SequenceMode::Infinite, ); diff --git a/examples/nrf/src/bin/pwm_sequence_ppi.rs b/examples/nrf/src/bin/pwm_sequence_ppi.rs index c80820f8..f5d734bb 100644 --- a/examples/nrf/src/bin/pwm_sequence_ppi.rs +++ b/examples/nrf/src/bin/pwm_sequence_ppi.rs @@ -16,7 +16,7 @@ use embassy_nrf::Peripherals; #[embassy::main] async fn main(_spawner: Spawner, p: Peripherals) { - let seq_words: [u16; 5] = [1000, 250, 100, 50, 0]; + let mut seq_words: [u16; 5] = [1000, 250, 100, 50, 0]; let mut config = Config::default(); config.prescaler = Prescaler::Div128; @@ -32,7 +32,7 @@ async fn main(_spawner: Spawner, p: Peripherals) { )); let _ = pwm.start( - Sequence::new(&seq_words, seq_config), + Sequence::new(&mut seq_words, seq_config), None, SequenceMode::Infinite, ); diff --git a/examples/nrf/src/bin/pwm_sequence_ws2812b.rs b/examples/nrf/src/bin/pwm_sequence_ws2812b.rs index 2fb37015..0ce79cbe 100644 --- a/examples/nrf/src/bin/pwm_sequence_ws2812b.rs +++ b/examples/nrf/src/bin/pwm_sequence_ws2812b.rs @@ -15,7 +15,9 @@ use embassy_nrf::Peripherals; // WS2812B LED light demonstration. Drives just one light. // The following reference on WS2812B may be of use: -// https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf +// https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf. +// This demo lights up a single LED in blue. It then proceeds +// to pulsate the LED rapidly. // In the following declarations, setting the high bit tells the PWM // to reverse polarity, which is what the WS2812B expects. @@ -29,17 +31,17 @@ const RES: u16 = 0x8000; #[embassy::main] async fn main(_spawner: Spawner, p: Peripherals) { // Declare the bits of 24 bits - let blue_seq_words = [ + let mut color_seq_words = [ T0H, T0H, T0H, T0H, T0H, T0H, T0H, T0H, // G T0H, T0H, T0H, T0H, T0H, T0H, T0H, T0H, // R T1H, T1H, T1H, T1H, T1H, T1H, T1H, T1H, // B ]; - let blue_seq = Sequence::new(&blue_seq_words, SequenceConfig::default()); + let color_seq = Sequence::new(&mut color_seq_words, SequenceConfig::default()); - let reset_seq_words = [RES; 1]; + let mut reset_seq_words = [RES; 1]; let mut reset_seq_config = SequenceConfig::default(); reset_seq_config.end_delay = 799; // 50us (20 ticks * 40) - 1 tick because we've already got one RES; - let reset_seq = Sequence::new(&reset_seq_words, reset_seq_config); + let reset_seq = Sequence::new(&mut reset_seq_words, reset_seq_config); let mut config = Config::default(); config.sequence_load = SequenceLoad::Common; @@ -49,8 +51,33 @@ async fn main(_spawner: Spawner, p: Peripherals) { p.PWM0, p.P1_05, NoPin, NoPin, NoPin, config, )); - unwrap!(pwm.start(blue_seq, Some(reset_seq), SequenceMode::Times(2))); + unwrap!(pwm.start(color_seq, Some(reset_seq), SequenceMode::Times(2))); - Timer::after(Duration::from_millis(20000)).await; - info!("Program stopped"); + Timer::after(Duration::from_millis(1000)).await; + + let mut color_bit = 16; + let mut bit_value = T0H; + + loop { + if let (Some(color_seq), Some(reset_seq)) = pwm.stop() { + color_seq.words[color_bit] = bit_value; + unwrap!(pwm.start(color_seq, Some(reset_seq), SequenceMode::Times(2))); + } + + Timer::after(Duration::from_millis(50)).await; + + if bit_value == T0H { + if color_bit == 20 { + bit_value = T1H; + } else { + color_bit += 1; + } + } else { + if color_bit == 16 { + bit_value = T0H; + } else { + color_bit -= 1; + } + } + } }