Clean up

Author: davidmweber

README.md

@@ -19,6 +19,8 @@ I started the project using the Espressif IDF (a powerful tool indeed) but switc
   ecosystem.
 - I chose the `#[no_std]` (i.e. no Espressif IDF) option, mostly to feel out the ecosystem in a pure Rust world. This
   is an art piece after all.
+- Async has some significant advantages, particularly with stack management and efficient concurrency so I have
+  made some effort to use async interfaces wherever possible.
 
 ## Hardware Requirements
 This project is based around the ESP32 family of embedded microprocessors with some basic requirements and a standard
@@ -58,6 +60,13 @@ some of the builds. Running `just --list` will show all the available tasks.
 
 
 
+## Useful links
+
+- [ESP32-C6 esp_hal documention](https://docs.esp-rs.org/esp-hal/esp-hal/0.23.1/esp32c6/esp_hal/)
+- [Rust on ESP book](https://docs.esp-rs.org/book/)
+- 
+
+
 # TODO
 
 - [ ] Set up hardware targets for the ESP32-S3 and ESP32-H2 targets

src/display_task.rs

@@ -1,48 +1,48 @@
-use embassy_futures::select::{select, Either};
+use crate::led_driver::LedDriver;
+use embassy_futures::select::{Either, select};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use smart_leds::RGB8;
 use embassy_sync::channel::Channel;
 use embassy_time::{Duration, Ticker};
 use log::info;
-use crate::led_driver::LedDriver;
+use smart_leds::RGB8;
 
 /// Manage the display state by sending it messages of this type. If anyone asks why I like Rust,
 /// this is one of the many reasons
 pub enum DisplayState {
     /// Suspends animation update
-    Stop, 
+    Stop,
     /// Restart animation update
     Start,
     /// Set the pixel colour. It is always the 1st pixel. Boring but....
     Colour(RGB8),
     /// Switch of all the LEDs
     Off,
     /// Sets the led to torch mode. This disables the animation
-    Torch(u8)
+    Torch(u8),
 }
 
 /// The channel type detail
 pub type DisplayControlChannel = Channel<CriticalSectionRawMutex, DisplayState, 3>;
 
-
 /// Display driver main task.
 /// The display is fully managed from this task. It contains the state and responds to messages
 /// sent to it via the channel.
 #[embassy_executor::task]
 pub async fn display_task(channel: &'static DisplayControlChannel, led: &'static mut LedDriver) {
     let mut ticker = Ticker::every(Duration::from_millis(100));
-    let mut running = false;
+    let mut running = true;
     info!("DISPLAY_TASK: Task started. Waiting for messages...");
-    led.update_string();
     loop {
         match select(ticker.next(), channel.receive()).await {
-            Either::First(_) => { // The ticker woke us up
+            Either::First(_) => {
+                // The ticker woke us up
                 if running {
                     led.rotate_left();
                     led.update_string();
                 }
             }
-            Either::Second(message) => { // We received a message
+            Either::Second(message) => {
+                // We received a message
                 use DisplayState::*;
                 match message {
                     Stop => running = false,
@@ -51,21 +51,19 @@ pub async fn display_task(channel: &'static DisplayControlChannel, led: &'static
                         led.all_off();
                         led.buffer[0] = c;
                         led.update_string();
-                    },
+                    }
                     Off => {
                         led.all_off();
                         led.update_string();
                         running = false;
-                    },
+                    }
                     Torch(c) => {
                         led.torch(c);
                         led.update_string();
                         running = false;
                     }
-                    
-                    
                 }
             }
         };
     }
-}
+}

src/led_driver.rs

@@ -53,15 +53,20 @@ impl LedDriver {
     pub fn rotate_right(&mut self) {
         self.buffer.rotate_left(1)
     }
-    
+
     /// Switches all the LEDS off
     #[allow(unused)]
     pub fn all_off(&mut self) {
         self.buffer.fill(RGB8 { r: 0, g: 0, b: 0 });
     }
-    
-    /// Switches all the LEDS to white at the specified brightness. 
-    pub fn torch(&mut self, brightness: u8)  {
-        self.buffer.fill(RGB8 { r: brightness, g: brightness, b: brightness });
+
+    /// Switches all the LEDS to white at the specified brightness.
+    #[allow(unused)]
+    pub fn torch(&mut self, brightness: u8) {
+        self.buffer.fill(RGB8 {
+            r: brightness,
+            g: brightness,
+            b: brightness,
+        });
     }
 }

src/main.rs

@@ -6,10 +6,11 @@
     holding buffers for the duration of a data transfer."
 )]
 
-extern crate alloc;
-mod led_driver;
 mod display_task;
+mod led_driver;
 
+use crate::display_task::DisplayState::*;
+use crate::display_task::{DisplayControlChannel, display_task};
 use crate::led_driver::LedDriver;
 use bt_hci::controller::ExternalController;
 use embassy_executor::Spawner;
@@ -18,14 +19,13 @@ use embassy_time::{Duration, Timer};
 use esp_hal::clock::CpuClock;
 use esp_hal::timer::systimer::SystemTimer;
 use esp_hal::timer::timg::TimerGroup;
+use esp_hal::{interrupt, peripherals};
 use esp_wifi::ble::controller::BleConnector;
 use log::info;
 #[cfg(feature = "log-rtt")]
 use rtt_target::rtt_init_log;
 use smart_leds::RGB8;
 use static_cell::StaticCell;
-use crate::display_task::{display_task, DisplayControlChannel};
-use crate::display_task::DisplayState::*;
 
 /// Communicate with the display task using this channel and the DisplayState enum
 static DISPLAY_CHANNEL: StaticCell<DisplayControlChannel> = StaticCell::new();
@@ -62,34 +62,43 @@ async fn main(spawner: Spawner) {
     let timer0 = SystemTimer::new(peripherals.SYSTIMER);
     esp_hal_embassy::init(timer0.alarm0);
 
+    info!("MAIN: Enabling RMT ISR");
+    interrupt::enable(peripherals::Interrupt::RMT, interrupt::Priority::Priority1).unwrap();
+
     info!("MAIN: Embassy initialized!");
 
     let rng = esp_hal::rng::Rng::new(peripherals.RNG);
     let timer1 = TimerGroup::new(peripherals.TIMG0);
     let wifi_init = esp_wifi::init(timer1.timer0, rng, peripherals.RADIO_CLK)
         .expect("MAIN: Failed to initialize WIFI/BLE controller");
-    
+
     // find more examples https://github.com/embassy-rs/trouble/tree/main/examples/esp32
     let transport = BleConnector::new(&wifi_init, peripherals.BT);
     let _ble_controller = ExternalController::<_, 20>::new(transport);
 
     info!("MAIN: Setting up LED driver controller");
     let display_channel = DISPLAY_CHANNEL.init(Channel::new());
-    let led_driver: &'static mut LedDriver = LED_DRIVER.init(LedDriver::new(peripherals.RMT, peripherals.GPIO6));
-    spawner.spawn(display_task(display_channel, led_driver)).expect("Failed to spawn display task");
-    
+    let led_driver: &'static mut LedDriver =
+        LED_DRIVER.init(LedDriver::new(peripherals.RMT, peripherals.GPIO6));
+
+    spawner
+        .spawn(display_task(display_channel, led_driver))
+        .expect("Failed to spawn display task");
+    Timer::after(Duration::from_secs(1)).await;
+
     // Simple example that exercises the display task
     loop {
-        display_channel.send(Off).await;
-        display_channel.send(Colour(RGB8::new(0,10,10))).await;
+        info!("MAIN: Loop cycling");
+        display_channel.send(Colour(RGB8::new(0, 10, 0))).await;
         display_channel.send(Start).await;
+        info!("MAIN: Sent start message");
 
         Timer::after(Duration::from_secs(10)).await;
         display_channel.send(Stop).await;
 
         Timer::after(Duration::from_secs(1)).await;
         display_channel.send(Start).await;
-        
+
         Timer::after(Duration::from_secs(1)).await;
         display_channel.send(Torch(10)).await;
 
@@ -98,6 +107,4 @@ async fn main(spawner: Spawner) {
 
         Timer::after(Duration::from_secs(1)).await;
     }
-
-    // for inspiration, have a look at the examples at https://github.com/esp-rs/esp-hal/tree/esp-hal-v1.0.0-beta.1/examples/src/bin
 }