Revert "Own the sequence buffer"

This reverts commit 482389a6911d8d3505872e6ad03d5b0af565eaf9.

3 files changed, 36 insertions, 32 deletions

diff --git a/examples/nrf/src/bin/pwm_sequence.rs b/examples/nrf/src/bin/pwm_sequence.rs
index 6fe957d24..6fb861e8f 100644
--- a/examples/nrf/src/bin/pwm_sequence.rs
+++ b/examples/nrf/src/bin/pwm_sequence.rs
@@ -8,13 +8,14 @@ use defmt::*;
 use embassy::executor::Spawner;
 use embassy::time::{Duration, Timer};
 use embassy_nrf::gpio::NoPin;
-use embassy_nrf::pwm::{
-    Config, Prescaler, Sequence, SequenceConfig, SequenceMode, SequencePwm, EMPTY_SEQ,
-};
+use embassy_nrf::pwm::{Config, Prescaler, Sequence, SequenceConfig, SequenceMode, SequencePwm};
 use embassy_nrf::Peripherals;
 
 #[embassy::main]
 async fn main(_spawner: Spawner, p: Peripherals) {
+    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;
     // 1 period is 1000 * (128/16mhz = 0.000008s = 0.008ms) = 8us
@@ -25,20 +26,25 @@ async fn main(_spawner: Spawner, p: Peripherals) {
     seq_config.refresh = 624;
     // thus our sequence takes 5 * 5000ms or 25 seconds
 
-    let seq_1 = Sequence::new([1000, 250, 100, 50, 0], seq_config.clone());
-    let seq_2 = Sequence::new([0, 50, 100, 250, 1000], seq_config);
-
     let mut pwm = unwrap!(SequencePwm::new(
         p.PWM0, p.P0_13, NoPin, NoPin, NoPin, config,
     ));
-    unwrap!(pwm.start(seq_1, EMPTY_SEQ, SequenceMode::Times(1)));
+    let _ = pwm.start(
+        Sequence::new(&mut seq_words_1, seq_config.clone()),
+        None,
+        SequenceMode::Infinite,
+    );
 
     info!("pwm started!");
 
     Timer::after(Duration::from_millis(20000)).await;
     info!("pwm starting with another sequence!");
 
-    unwrap!(pwm.start(seq_2, EMPTY_SEQ, SequenceMode::Times(1)));
+    let _ = pwm.start(
+        Sequence::new(&mut seq_words_2, seq_config),
+        None,
+        SequenceMode::Infinite,
+    );
 
     // we can abort a sequence if we need to before its complete with pwm.stop()
     // or stop is also implicitly called when the pwm peripheral is dropped
diff --git a/examples/nrf/src/bin/pwm_sequence_ppi.rs b/examples/nrf/src/bin/pwm_sequence_ppi.rs
index 4883222a8..f5d734bb1 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;
@@ -31,12 +31,11 @@ async fn main(_spawner: Spawner, p: Peripherals) {
         p.PWM0, p.P0_13, NoPin, NoPin, NoPin, config,
     ));
 
-    // If we loop in any way i.e. not Times(1), then we must provide
-    // the PWM peripheral with two sequences.
-    let seq_0 = Sequence::new(seq_words, seq_config);
-    let seq_1 = seq_0.clone();
-
-    unwrap!(pwm.start(seq_0, seq_1, SequenceMode::Infinite));
+    let _ = pwm.start(
+        Sequence::new(&mut seq_words, seq_config),
+        None,
+        SequenceMode::Infinite,
+    );
     // pwm.stop() deconfigures pins, and then the task_start_seq0 task cant work
     // so its going to have to start running in order load the configuration
 
diff --git a/examples/nrf/src/bin/pwm_sequence_ws2812b.rs b/examples/nrf/src/bin/pwm_sequence_ws2812b.rs
index 8acb209cc..0ce79cbe0 100644
--- a/examples/nrf/src/bin/pwm_sequence_ws2812b.rs
+++ b/examples/nrf/src/bin/pwm_sequence_ws2812b.rs
@@ -30,6 +30,19 @@ const RES: u16 = 0x8000;
 // line is assumed to be P1_05.
 #[embassy::main]
 async fn main(_spawner: Spawner, p: Peripherals) {
+    // Declare the bits of 24 bits
+    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 color_seq = Sequence::new(&mut color_seq_words, SequenceConfig::default());
+
+    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(&mut reset_seq_words, reset_seq_config);
+
     let mut config = Config::default();
     config.sequence_load = SequenceLoad::Common;
     config.prescaler = Prescaler::Div1;
@@ -38,21 +51,7 @@ async fn main(_spawner: Spawner, p: Peripherals) {
         p.PWM0, p.P1_05, NoPin, NoPin, NoPin, config,
     ));
 
-    // Declare the bits of 24 bits
-    let color_seq = Sequence::new(
-        [
-            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
-        ],
-        SequenceConfig::default(),
-    );
-
-    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([RES], reset_seq_config);
-
-    unwrap!(pwm.start(color_seq, reset_seq, SequenceMode::Times(2)));
+    unwrap!(pwm.start(color_seq, Some(reset_seq), SequenceMode::Times(2)));
 
     Timer::after(Duration::from_millis(1000)).await;
 
@@ -60,9 +59,9 @@ async fn main(_spawner: Spawner, p: Peripherals) {
     let mut bit_value = T0H;
 
     loop {
-        if let (Some(mut color_seq), Some(reset_seq)) = pwm.stop() {
+        if let (Some(color_seq), Some(reset_seq)) = pwm.stop() {
             color_seq.words[color_bit] = bit_value;
-            unwrap!(pwm.start(color_seq, reset_seq, SequenceMode::Times(2)));
+            unwrap!(pwm.start(color_seq, Some(reset_seq), SequenceMode::Times(2)));
         }
 
         Timer::after(Duration::from_millis(50)).await;