platform: esp32: first attempt at an i2s implementation, and fix rmt flickering with thread magic

.cargo/config.toml

@@ -1,16 +1,22 @@
 [build]
-target = "xtensa-esp32-espidf"
+target = "xtensa-esp32s3-espidf"
+
+[target.xtensa-esp32s3-espidf]
+linker = "ldproxy"
+runner = "espflash flash --monitor --no-stub" # Select this runner for espflash v3.x.x
+rustflags = [ "--cfg",  "espidf_time64"] # Extending time_t for ESP IDF 5: https://github.com/esp-rs/rust/issues/110
+rust-env = {MCU = "esp32s3"}
 
 [target.xtensa-esp32-espidf]
 linker = "ldproxy"
-runner = "espflash flash --monitor" # Select this runner for espflash v3.x.x
+runner = "espflash flash --monitor --no-stub" # Select this runner for espflash v3.x.x
 rustflags = [ "--cfg",  "espidf_time64"] # Extending time_t for ESP IDF 5: https://github.com/esp-rs/rust/issues/110
+rust-env = {MCU = "esp32"}
 
 [unstable]
 build-std = ["std", "panic_abort"]
 
 [env]
-MCU="esp32"
 # Note: this variable is not used by the pio builder (`cargo build --features pio`)
 ESP_IDF_VERSION = "v5.2.2"
 

Cargo.toml

@@ -18,29 +18,36 @@ debug = true    # Symbols are nice and they don't increase the size on Flash
 opt-level = "z"
 
 [features]
-default = ["std", "embassy", "esp-idf-svc/native"]
+default = ["std", "esp-idf-svc/native", "rmt", "smart-leds"]
+
+embedded-graphics = ["dep:embedded-graphics", "ws2812-esp32-rmt-driver/embedded-graphics-core"]
+smart-leds = ["dep:smart-leds", "dep:smart-leds-trait", "ws2812-esp32-rmt-driver/smart-leds-trait"]
+spi = ["dep:ws2812-spi"]
+rmt = ["dep:ws2812-esp32-rmt-driver"]
 
 pio = ["esp-idf-svc/pio"]
 std = ["alloc", "esp-idf-svc/binstart", "esp-idf-svc/std"]
 alloc = ["esp-idf-svc/alloc"]
-nightly = ["esp-idf-svc/nightly"]
-experimental = ["esp-idf-svc/experimental"]
-embassy = ["esp-idf-svc/embassy-sync", "esp-idf-svc/critical-section", "esp-idf-svc/embassy-time-driver"]
 
 [dependencies]
 log = { version = "0.4", default-features = false }
 esp-idf-svc = { version = "0.49", default-features = false }
-ws2812-esp32-rmt-driver = { version = "*", features = ["embedded-graphics-core", "smart-leds-trait"]}
-embedded-graphics = { version = "0.8.1", features = ["fixed_point", "defmt"] }
 hsv = "0.1.1"
 palette = { version = "0.7.6" }
-embedded-canvas = "0.3.1"
-embassy-executor = "0.6.0"
 running-average = "0.1.0"
-ws2812-spi = "0.5.0"
-smart-leds-trait = "0.3.0"
 rgb = "0.8.50"
-smart-leds = "0.4.0"
+
+ws2812-esp32-rmt-driver = { version = "*", optional = true }
+
+ws2812-spi = { version = "0.5.0", optional = true }
+
+smart-leds-trait = { version = "0.3.0", optional = true }
+smart-leds = { version = "0.4.0", optional = true }
+
+embedded-graphics = { version = "0.8.1", optional = true, features = ["fixed_point", "defmt"] }
+ansi_term = "0.12.1"
+num = "0.4.3"
+chrono = "0.4.38"
 
 [build-dependencies]
 embuild = "0.32.0"

sdkconfig.defaults

@@ -3,9 +3,15 @@ CONFIG_ESP_MAIN_TASK_STACK_SIZE=8000
 
 # Use this to set FreeRTOS kernel tick frequency to 1000 Hz (100 Hz by default).
 # This allows to use 1 ms granularity for thread sleeps (10 ms by default).
-#CONFIG_FREERTOS_HZ=1000
+CONFIG_FREERTOS_HZ=1000
 
 # Workaround for https://github.com/espressif/esp-idf/issues/7631
 #CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=n
 #CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=n
-CONFIG_ESP32_XTAL_FREQ_26=y
+#CONFIG_ESP32_XTAL_FREQ_26=y
+
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_40=
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_80=
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160=
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ=240

src/TODO.md

@@ -0,0 +1,15 @@
+[x] cfg macros
+[ ] warnings
+[x] rgb crate
+[ ] Layer blending
+[ ] Refactor idle pattern into test pattern
+[ ] Wifi
+[ ] JSON surface map loading
+[ ] Weather
+[ ] Circadian Rhythm
+[ ] NTP
+[ ] Config to only start a subset of tasks on startup
+[ ] Serial CLI
+[ ] Surface blending API
+[ ] Layer blending equations
+[ ] Surface rotation

src/animations.rs

@@ -0,0 +1,203 @@
+use palette::Hsv;
+
+use rgb::RGB8;
+
+use crate::time::Periodically;
+use crate::geometry::*;
+use crate::render::{Shader, Surface, Surfaces};
+use crate::task::Task;
+use crate::lib8::{trig::{sin8, cos8}, interpolate::scale8, noise::inoise8, IntoRgb8};
+
+#[derive(Debug)]
+pub struct IdleTask<T: Surface> {
+    solid: T,
+    surface: T,
+    shimmer: T,
+}
+
+#[derive(Debug)]
+struct SolidShader {}
+
+impl Shader for SolidShader {
+    fn draw(&self, _coords: &VirtualCoordinates, frame: usize) -> RGB8 {
+        Hsv::new_srgb((frame % 255) as u8, 255, sin8((frame % 64) as u8)).into_rgb8()
+    }
+}
+
+#[derive(Debug)]
+struct ShimmerShader {}
+
+impl Shader for ShimmerShader {
+    fn draw(&self, coords: &VirtualCoordinates, frame: usize) -> RGB8 {
+        Hsv::new_srgb(((coords.x as usize).wrapping_add(frame / 3) % 255) as u8, coords.y, sin8(frame).max(75).min(64)).into_rgb8()
+    }
+}
+
+#[derive(Debug)]
+struct ThinkingShader {}
+
+impl Shader for ThinkingShader {
+    fn draw(&self, coords: &VirtualCoordinates, frame: usize) -> RGB8 {
+        //let noise_x = sin8(sin8((frame % 255) as u8).wrapping_add(coords.x));
+        //let noise_y = cos8(cos8((frame % 255) as u8).wrapping_add(coords.y));
+        let offset_x = sin8(frame.wrapping_add(coords.x as usize));
+        let offset_y = cos8(frame.wrapping_add(coords.y as usize));
+        let noise_x = offset_x / 2;
+        let noise_y = offset_y / 2;
+        //let noise_x = coords.x.wrapping_add(offset_x);
+        //let noise_y = coords.y.wrapping_add(offset_y);
+        Hsv::new_srgb(
+            inoise8(offset_x as i16, offset_y as i16),
+            128_u8.saturating_add(inoise8(noise_y as i16, noise_x as i16)),
+            255
+        ).into_rgb8()
+    }
+}
+
+impl<T: Surface> IdleTask<T> {
+    pub fn new<S: Surfaces<Surface = T>>(surfaces: &mut S) -> Self {
+        IdleTask {
+            solid: surfaces.new_surface(&Rectangle::everything()).unwrap(),
+            surface: surfaces.new_surface(&Rectangle::everything()).unwrap(),
+            shimmer: surfaces.new_surface(&Rectangle::everything()).unwrap(),
+        }
+    }
+}
+
+impl<T: Surface> Task for IdleTask<T> {
+    fn start(&mut self) {
+        self.solid.set_shader(Box::new(SolidShader { }));
+        self.surface.set_shader(Box::new(ThinkingShader { }));
+        self.shimmer.set_shader(Box::new(ShimmerShader { }));
+
+        self.solid.set_opacity(64);
+        self.surface.set_opacity(128);
+        self.shimmer.set_opacity(64);
+    }
+
+    fn tick(&mut self) {}
+
+    fn stop(&mut self) {
+        self.solid.clear_shader();
+        self.surface.clear_shader();
+        self.shimmer.clear_shader();
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum TestShader {
+    Red,
+    Green,
+    Blue,
+    White,
+    RGB,
+    HSV,
+    Outline,
+    SweepX,
+    SweepY,
+    SinX,
+    SinY,
+    Metaballs
+}
+
+impl TestShader {
+    pub fn next(self) -> Self {
+        match self {
+            Self::Red => Self::Green,
+            Self::Green => Self::Blue,
+            Self::Blue => Self::White,
+            Self::White => Self::RGB,
+            Self::RGB => Self::HSV,
+            Self::HSV => Self::Outline,
+            Self::Outline => Self::SweepX,
+            Self::SweepX => Self::SweepY,
+            Self::SweepY => Self::SinX,
+            Self::SinX => Self::SinY,
+            Self::SinY => Self::Metaballs,
+            Self::Metaballs => Self::Red
+        }
+    }
+}
+
+impl Shader for TestShader {
+    fn draw(&self, coords: &VirtualCoordinates, frame: usize) -> RGB8 {
+        match self {
+            Self::Red => RGB8::new(255, 0, 0),
+            Self::Green => RGB8::new(0, 255, 0),
+            Self::Blue => RGB8::new(0, 0, 255),
+            Self::White => RGB8::new(255, 255, 255),
+            Self::RGB => RGB8::new(coords.x, coords.y, 255 - (coords.x / 2 + coords.y / 2)),
+            Self::HSV => Hsv::new_srgb(coords.x, coords.y, 255).into_rgb8(),
+            Self::Outline => match (coords.x, coords.y) {
+                (0, 0) => RGB8::new(255, 255, 255),
+                (0, _) => RGB8::new(255, 0, 0),
+                (_, 0) => RGB8::new(0, 255, 0),
+                (255, _) => RGB8::new(0, 0, 255),
+                (_, 255) => RGB8::new(0, 0, 255),
+                _ => RGB8::new(0, 0, 0)
+            },
+            Self::SweepX => RGB8::new(255, 0, 0),
+            Self::SweepY => RGB8::new(255, 0, 0),
+            Self::SinX => RGB8::new(sin8(coords.x.wrapping_add((frame % 255) as u8)), 0, 0),
+            Self::SinY => RGB8::new(sin8(coords.y.wrapping_add((frame % 255) as u8)), 0, 0),
+            Self::Metaballs => {
+                let ball_center = Coordinates::new(
+                    scale8(64, sin8(frame)) + 128,
+                    scale8(64, cos8(frame)) + 128
+                );
+                let dist = 255 - coords.distance_to(&ball_center);
+                RGB8::new(dist, 0, 0)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TestPattern<T: Surface> {
+    surface: T,
+    updater: Periodically,
+    stepper: Periodically,
+    pattern: TestShader,
+    frame: u8
+}
+
+impl<T: Surface> TestPattern<T> {
+    pub fn new(surface: T) -> Self {
+        TestPattern { surface, updater: Periodically::new_every_n_seconds(10), stepper: Periodically::new_every_n_ms(60), pattern: TestShader::HSV, frame: 0 }
+    }
+}
+
+impl<T: Surface> Task for TestPattern<T> {
+    fn start(&mut self) {
+        self.surface.set_shader(Box::new(self.pattern.clone()));
+    }
+
+    fn tick(&mut self) {
+        self.updater.run(|| {
+            self.pattern = self.pattern.next();
+            log::info!("Test pattern: {:?}", self.pattern);
+            self.frame = 0;
+            self.surface.set_shader(Box::new(self.pattern.clone()));
+        });
+        self.stepper.run(|| {
+            self.frame = self.frame.wrapping_add(1);
+            self.surface.set_opacity(sin8(self.frame));
+            //log::info!("Step {}", self.frame);
+            self.surface.set_rect( &match self.pattern {
+                TestShader::SweepX => Rectangle::new(
+                    Coordinates::new(self.frame, 0),
+                    Coordinates::new(self.frame, 255)
+                ),
+                TestShader::SweepY => Rectangle::new(
+                    Coordinates::new(0, self.frame),
+                    Coordinates::new(255, self.frame)
+                ),
+                _ => Rectangle::everything()
+            });
+        });
+    }
+
+    fn stop(&mut self) {
+        self.surface.clear_shader();
+    }
+}

src/buffers.rs

@@ -0,0 +1,348 @@
+use crate::geometry::*;
+use crate::lib8::interpolate::Fract8Ops;
+use crate::power::AsMilliwatts;
+use crate::render::{PixelView, Sample, Shader, Surface, Surfaces, HardwarePixel};
+use crate::task::Task;
+
+use std::fmt::Debug;
+use std::io;
+use std::ops::IndexMut;
+
+use std::sync::atomic::AtomicBool;
+use std::sync::RwLock;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+struct ShaderBinding {
+    shader: Option<Box<dyn Shader>>,
+    rect: Rectangle<Virtual>,
+    opacity: u8
+}
+
+#[derive(Debug)]
+struct SurfaceUpdate {
+    shader: Option<Option<Box<dyn Shader>>>,
+    rect: Option<Rectangle<Virtual>>,
+    opacity: Option<u8>,
+    slot: usize
+}
+
+impl SurfaceUpdate {
+    fn merge(&mut self, mut other: Self) {
+        if other.shader.is_some() {
+            self.shader = other.shader.take()
+        }
+        if other.rect.is_some() {
+            self.rect = other.rect.take()
+        }
+        if other.opacity.is_some() {
+            self.opacity = other.opacity.take()
+        }
+    }
+}
+
+impl Debug for Box<dyn Shader> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Shader").finish()
+    }
+}
+
+impl Default for SurfaceUpdate {
+    fn default() -> Self {
+        SurfaceUpdate {
+            shader: None,
+            rect: None,
+            opacity: None,
+            slot: usize::MAX
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct BufferedSurface {
+    updater: Arc<UpdateQueue>,
+    slot: usize
+}
+
+impl Surface for BufferedSurface {
+    fn clear_shader(&mut self) {
+        self.updater.push(SurfaceUpdate {
+            shader: None,
+            slot: self.slot,
+            ..Default::default()
+        });
+    }
+
+    fn set_opacity(&mut self, opacity: u8) {
+        self.updater.push(SurfaceUpdate {
+            opacity: Some(opacity),
+            slot: self.slot,
+            ..Default::default()
+        });
+    }
+
+    fn set_rect(&mut self, rect: &Rectangle<Virtual>) {
+        self.updater.push(SurfaceUpdate {
+            rect: Some(rect.clone()),
+            slot: self.slot,
+            ..Default::default()
+        });
+    }
+
+    fn set_shader(&mut self, shader: Box<dyn Shader>) {
+        self.updater.push(SurfaceUpdate {
+            shader: Some(Some(shader)),
+            slot: self.slot,
+            ..Default::default()
+        });
+    }
+}
+
+#[derive(Debug)]
+struct UpdateQueue {
+    pending: Mutex<Vec<SurfaceUpdate>>,
+    damaged: AtomicBool
+}
+
+impl UpdateQueue {
+    fn new() -> Self {
+        UpdateQueue {
+            pending: Mutex::new(Vec::new()),
+            damaged: AtomicBool::new(false)
+        }
+    }
+
+    fn push(&self, update: SurfaceUpdate) {
+        let mut locked = self.pending.lock().unwrap();
+        let mut existing_slot = None;
+        for existing in locked.iter_mut() {
+            if existing.slot == update.slot {
+                existing_slot = Some(existing);
+                break
+            }
+        }
+        match existing_slot {
+            Some(tgt) => {
+                log::debug!("Updating existing shader update");
+                tgt.merge(update);
+            }
+            _ => {
+                log::debug!("Pushing new shader update");
+                locked.push(update);
+                self.damaged.store(true, std::sync::atomic::Ordering::Relaxed);
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ShaderChain {
+    bindings: Vec<ShaderBinding>,
+    updates: Arc<UpdateQueue>
+}
+
+impl ShaderChain {
+    pub fn new() -> Self {
+        ShaderChain {
+            bindings: Vec::new(),
+            updates: Arc::new(UpdateQueue::new())
+        }
+    }
+
+    pub fn is_dirty(&self) -> bool {
+        self.updates.damaged.load(std::sync::atomic::Ordering::Relaxed)
+    }
+
+    pub fn commit(&mut self) {
+        let mut queue: Vec<SurfaceUpdate> = {
+            let mut updates = self.updates.pending.lock().unwrap();
+            std::mem::take(updates.as_mut())
+        };
+        for update in queue.iter_mut() {
+            let target_slot = &mut self.bindings[update.slot];
+            if let Some(shader) = update.shader.take() {
+                target_slot.shader = shader;
+            }
+            if let Some(opacity) = update.opacity.take() {
+                target_slot.opacity = opacity;
+            }
+            if let Some(rect) = update.rect.take() {
+                target_slot.rect = rect;
+            }
+        }
+        self.updates.damaged.store(false, std::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl Surfaces for ShaderChain {
+    type Error = ();
+    type Surface = BufferedSurface;
+
+    fn new_surface(&mut self, area: &Rectangle<Virtual>) -> Result<Self::Surface, Self::Error> {
+        let next_slot = self.bindings.len();
+        self.bindings.push(ShaderBinding {
+            opacity: 255,
+            shader: None,
+            rect: area.clone()
+        });
+
+        Ok(BufferedSurface {
+            updater: Arc::clone(&self.updates),
+            slot: next_slot
+        })
+    }
+
+    fn render_to<S: Sample>(&self, output: &mut S, frame: usize) {
+        for surface in self.bindings.iter() {
+            let opacity = surface.opacity;
+            if opacity > 0 {
+                let rect = surface.rect;
+                let mut sample = output.sample(&rect);
+                if let Some(ref shader) = surface.shader {
+                    while let Some((virt_coords, pixel)) = sample.next() {
+                        *pixel = pixel.blend8(shader.draw(&virt_coords, frame).into(), opacity);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct BufferedSurfacePool {
+    pool: Arc<RwLock<ShaderChain>>
+}
+
+impl BufferedSurfacePool {
+    pub fn new() -> Self {
+        BufferedSurfacePool {
+            pool: Arc::new(RwLock::new(ShaderChain::new()))
+        }
+    }
+}
+
+impl Surfaces for BufferedSurfacePool {
+    type Error = ();
+    type Surface = <ShaderChain as Surfaces>::Surface;
+    fn new_surface(&mut self, area: &crate::geometry::Rectangle<crate::geometry::Virtual>) -> Result<Self::Surface, Self::Error> {
+        self.pool.write().unwrap().new_surface(area)
+    }
+
+    fn render_to<S: crate::render::Sample>(&self, output: &mut S, frame: usize) {
+        self.pool.read().unwrap().render_to(output, frame);
+    }
+}
+
+
+impl Task for BufferedSurfacePool {
+    fn tick(&mut self) {
+        if self.pool.read().unwrap().is_dirty() {
+            self.pool.write().unwrap().commit();
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct SharedSurface {
+    binding: Arc<Mutex<ShaderBinding>>
+}
+
+
+impl Default for SharedSurface {
+    fn default() -> Self {
+        Self {
+            binding: Arc::new(Mutex::new(ShaderBinding {
+                shader: None,
+                rect: Rectangle::everything(),
+                opacity: 255
+            })),
+        }
+    }
+}
+
+impl Surface for SharedSurface {
+    fn set_shader(&mut self, shader: Box<dyn Shader>) {
+        self.binding.lock().unwrap().shader = Some(shader);
+    }
+
+    fn clear_shader(&mut self) {
+        self.binding.lock().unwrap().shader = None;
+    }
+
+    fn set_rect(&mut self, rect: &Rectangle<Virtual>) {
+        self.binding.lock().unwrap().rect = rect.clone();
+    }
+
+    fn set_opacity(&mut self, opacity: u8) {
+        self.binding.lock().unwrap().opacity = opacity
+    }
+}
+
+
+#[derive(Clone)]
+pub struct SurfacePool {
+    surfaces: Vec<SharedSurface>
+}
+
+impl SurfacePool {
+    pub const fn new() -> Self {
+        Self {
+            surfaces: Vec::new()
+        }
+    }
+}
+
+impl Surfaces for SurfacePool {
+    type Surface = SharedSurface;
+    type Error = io::Error;
+    fn new_surface(&mut self, area: &Rectangle<Virtual>) -> Result<Self::Surface, Self::Error> {
+        let mut surface = SharedSurface::default();
+        surface.set_rect(area);
+        self.surfaces.push(surface.clone());
+        return Ok(surface);
+    }
+
+    fn render_to<Sampler: Sample>(&self, output: &mut Sampler, frame: usize) {
+        for surface in self.surfaces.iter() {
+            let binding = surface.binding.lock().unwrap();
+            let opacity = binding.opacity;
+            if opacity > 0 {
+                let rect = binding.rect;
+                let mut sample = output.sample(&rect);
+
+                if let Some(ref shader) = binding.shader {
+                    while let Some((virt_coords, pixel)) = sample.next() {
+                        *pixel = pixel.blend8(shader.draw(&virt_coords, frame).into(), opacity);
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub trait Pixbuf: AsMilliwatts + IndexMut<usize, Output=Self::Pixel> + Send {
+    type Pixel: HardwarePixel;
+    fn new() -> Self;
+    fn blank(&mut self);
+    fn iter_with_brightness(&self, brightness: u8) -> impl Iterator<Item = Self::Pixel> + Send;
+    fn pixel_count(&self) -> usize;
+}
+
+impl<T: HardwarePixel, const PIXEL_NUM: usize> Pixbuf for [T; PIXEL_NUM] {
+    type Pixel = T;
+    fn new() -> Self {
+        [T::default(); PIXEL_NUM]
+    }
+
+    fn pixel_count(&self) -> usize {
+        self.len()
+    }
+
+    fn blank(&mut self) {
+        self.fill(T::default())
+    }
+
+    fn iter_with_brightness(&self, brightness: u8) -> impl Iterator<Item=T> + Send {
+        self.iter().map(move |x| { x.scale8(brightness)})
+    }
+}

src/embedded_graphics_lib.rs

@@ -1,126 +0,0 @@
-use embedded_graphics::{
-    prelude::*,
-    pixelcolor::Rgb888,
-    primitives::Rectangle
-};
-use embedded_graphics::pixelcolor::RgbColor;
-use ws2812_esp32_rmt_driver::lib_embedded_graphics::{Ws2812DrawTarget, LedPixelShape};
-
-use running_average::RealTimeRunningAverage;
-use std::io;
-
-use crate::power;
-use crate::power::AsMilliwatts;
-use crate::lib8::*;
-use crate::render::*;
-use crate::time::Periodically;
-use crate::task::Task;
-use crate::geometry::*;
-
-impl<T: RgbColor> AsMilliwatts for T {
-    fn as_milliwatts(&self) -> u32 {
-        const RED_MW : u32   = 16 * 5; //< 16mA @ 5v = 80mW
-        const GREEN_MW : u32 = 11 * 5; //< 11mA @ 5v = 55mW
-        const BLUE_MW : u32  = 15 * 5; //< 15mA @ 5v = 75mW
-        const DARK_MW : u32  =  1 * 5; //<  1mA @ 5v =  5mW
-
-        let red = (self.r() as u32 * RED_MW).wrapping_shr(8);
-        let green = (self.g() as u32 * GREEN_MW).wrapping_shr(8);
-        let blue = (self.b() as u32 * BLUE_MW).wrapping_shr(8);
-
-        return red + green + blue + DARK_MW;
-    }
-}
-
-pub struct EmbeddedDisplay<T, S>
-where
-T: DrawTarget,
-S: Surface {
-    surfaces : SurfacePool<S>,
-    target: T,
-    total_mw: u32,
-    max_mw: u32,
-    fps: RealTimeRunningAverage<u32>,
-    frame: u32,
-    fps_display: Periodically
-}
-
-impl<T: LedPixelShape, S: Surface> Task for EmbeddedDisplay<Ws2812DrawTarget<'_, T>, S> {
-    fn start(&mut self) {
-        self.target.set_brightness(0);
-    }
-
-    fn name(&self) -> &'static str { "Renderer" }
-
-    fn tick(&mut self) {
-        self.start_frame();
-        self.render_frame();
-        self.end_frame();
-    }
-}
-
-impl<T, S> EmbeddedDisplay<T, S>
-where
-T: DrawTarget,
-S: Surface {
-    pub fn new(target: T, max_mw: u32) -> Self {
-        EmbeddedDisplay {
-            surfaces: SurfacePool::new(),
-            target: target,
-            max_mw: max_mw,
-            total_mw: 0,
-            fps: RealTimeRunningAverage::default(),
-            frame: 0,
-            fps_display: Periodically::new_every_n_seconds(5)
-        }
-    }
-}
-
-impl<T, S> Surfaces<S> for EmbeddedDisplay<T, S>
-where
-T: DrawTarget,
-S: Surface {
-    fn new_surface(&mut self) -> Result<S, io::Error> {
-        self.surfaces.new_surface()
-    }
-}
-
-impl<T: LedPixelShape, S: Surface> Display<S> for EmbeddedDisplay<Ws2812DrawTarget<'_, T>, S> {
-
-    fn start_frame(&mut self) {
-        self.total_mw = 0;
-        self.frame = self.frame.wrapping_add(1);
-    }
-
-    fn end_frame(&mut self) {
-        let brightness = power::brightness_for_mw(self.total_mw, 255, self.max_mw);
-        self.target.set_brightness(brightness);
-        self.target.flush().unwrap();
-        self.fps.insert(1);
-        self.fps_display.run(|| {
-            log::info!("FPS: {} frame={} brightness={} mw={}", self.fps.measurement(), self.frame, brightness, self.total_mw);
-        });
-    }
-
-    fn render_frame(&mut self) {
-        let size = T::size();
-        let xStride: u8 = 255 / (size.width as u8);
-        let yStride: u8 = 255 / (size.height as u8);
-        let area = Rectangle::new(Point::new(0, 0), size);
-
-        self.target.draw_iter(
-            area.points()
-            .map(|pos| {
-                let virtCoords = VirtualCoordinates::new(pos.x as u8 * xStride, pos.y as u8 * yStride);
-                let mut pixel = RGB8::new(0, 0, 0);
-                for surface in self.surfaces.iter() {
-                    surface.with_shader(|shader| {
-                        pixel = shader.draw(virtCoords.clone());
-                    })
-                }
-                self.total_mw += pixel.as_milliwatts();
-                return Pixel(pos, Rgb888::new(pixel.red, pixel.green, pixel.blue));
-            })
-        ).unwrap();
-    }
-}

src/geometry.rs

@@ -1,53 +1,142 @@
-use std::marker::PhantomData;
+use core::fmt::{Debug, Formatter};
+use core::ops::{Mul, Sub, Add};
+use num::{One, pow, integer::Roots};
+use core::cmp::{min, max};
 
-pub trait CoordinateSpace {}
+pub trait CoordinateOp: PartialOrd + PartialEq + Sub + Clone + Mul + Copy + One + Add + Eq + Debug where
+Self: Sub<Output=Self> {
+    const MIN: Self;
+    const MAX: Self;
+    fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self;
+}
 
-pub trait Coordinates<T, S: CoordinateSpace> {
-    fn x(&self) -> T;
-    fn y(&self) -> T;
-    fn new(x: T, y: T) -> Self;
+pub trait CoordinateSpace {
+    type Data: CoordinateOp;
+}
 
-    const MAX: T;
-    const MIN: T;
+#[derive(PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
+pub struct Coordinates<S: CoordinateSpace> {
+    pub x: S::Data,
+    pub y: S::Data,
+}
+
+impl<S: CoordinateSpace> Debug for Coordinates<S> where S::Data: Debug {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("@")
+            .field(&self.x)
+            .field(&self.y)
+            .finish()
+    }
+}
+
+impl CoordinateOp for u8 {
+    const MIN: u8 = 0;
+    const MAX: u8 = 255;
+
+    fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
+        (max(x2, x1) - min(x2, x1)).saturating_add(max(y2, y1) - min(y2, y1))
+    }
+}
+
+impl CoordinateOp for u16 {
+    const MIN: u16 = u16::MIN;
+    const MAX: u16 = u16::MAX;
+
+    fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
+        (pow(x2 - x1, 2) + pow(y2 - y1, 2)).sqrt()
+    }
+}
+
+impl CoordinateOp for usize {
+    const MIN: usize = usize::MIN;
+    const MAX: usize = usize::MAX;
+
+    fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
+        (pow(x2 - x1, 2) + pow(y2 - y1, 2)).sqrt()
+    }
+}
+
+impl<S: CoordinateSpace> Coordinates<S> {
+    pub const fn new(x: S::Data, y: S::Data) -> Self {
+        Self {
+            x,
+            y
+        }
+    }
+
+    fn top_left() -> Self {
+        Self::new(S::Data::MIN, S::Data::MIN)
+    }
+
+    fn top_right() -> Self {
+        Self::new(S::Data::MAX, S::Data::MIN)
+    }
+
+    fn bottom_left() -> Self {
+        Self::new(S::Data::MIN, S::Data::MAX)
+    }
+
+    fn bottom_right() -> Self {
+        Self::new(S::Data::MAX, S::Data::MAX)
+    }
+
+    pub fn distance_to(&self, other: &Self) -> S::Data {
+        S::Data::distance(self.x, other.x, self.y, other.y)
+    }
 }
 
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct Virtual {}
-impl CoordinateSpace for Virtual {}
-
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Physical {}
-impl CoordinateSpace for Physical {}
-
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Coord8<S: CoordinateSpace> {
-    x: u8,
-    y: u8,
-    space: PhantomData<S>
+impl CoordinateSpace for Virtual {
+    type Data = u8;
 }
 
-pub type VirtualCoordinates = Coord8<Virtual>;
-pub type PhysicalCoordinates = Coord8<Physical>;
+pub type VirtualCoordinates = Coordinates<Virtual>;
 
-impl<S> Coordinates<u8, S> for Coord8<S>
-where
-S: CoordinateSpace {
-    fn new(x: u8, y: u8) -> Self {
+#[derive(PartialEq, Eq, Copy, Clone, Debug, PartialOrd)]
+pub struct Rectangle<Space: CoordinateSpace> {
+    pub top_left: Coordinates<Space>,
+    pub bottom_right: Coordinates<Space>
+}
+
+impl<Space: CoordinateSpace> Rectangle<Space> {
+    pub const fn new(top_left: Coordinates<Space>, bottom_right: Coordinates<Space>) -> Self {
+        //debug_assert!(top_left.x <= bottom_right.x);
+        //debug_assert!(top_left.y <= bottom_right.y);
         Self {
-            x: x,
-            y: y,
-            space: PhantomData
+            top_left,
+            bottom_right
         }
     }
 
-    fn x(&self) -> u8 {
-        self.x
+    pub fn everything() -> Self {
+        Self {
+            top_left: Coordinates::<Space>::top_left(),
+            bottom_right: Coordinates::<Space>::bottom_right()
+        }
     }
 
-    fn y(&self) -> u8 {
-        self.y
+    pub fn width(&self) -> Space::Data {
+        self.bottom_right.x - self.top_left.x
     }
 
-    const MAX: u8 = 255;
-    const MIN: u8 = 255;
+    pub fn height(&self) -> Space::Data {
+        self.bottom_right.y - self.top_left.y
+    }
+
+    pub const fn left(&self) -> Space::Data {
+        self.top_left.x
+    }
+
+    pub const fn top(&self) -> Space::Data {
+        self.top_left.y
+    }
+
+    pub const fn right (&self) -> Space::Data {
+        self.bottom_right.x
+    }
+
+    pub const fn bottom(&self) -> Space::Data {
+        self.bottom_right.y
+    }
 }

src/lib8.rs

@@ -1,72 +0,0 @@
-use palette::convert::FromColorUnclamped;
-use palette::encoding::srgb::Srgb;
-use palette::Hsv;
-use embedded_graphics::pixelcolor::RgbColor;
-use embedded_graphics::pixelcolor::PixelColor;
-use embedded_graphics::pixelcolor::raw::RawU8;
-
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct RGB8 {
-    pub red: u8,
-    pub green: u8,
-    pub blue: u8
-}
-
-impl RGB8 {
-    pub const fn new(red : u8, green : u8, blue : u8) -> Self {
-        Self {
-            red: red,
-            green: green,
-            blue: blue
-        }
-    }
-}
-
-impl RgbColor for RGB8 {
-    fn r(&self) -> u8 { self.red }
-    fn g(&self) -> u8 { self.green }
-    fn b(&self) -> u8 { self.blue }
-
-    const MAX_R: u8 = 255;
-    const MAX_G: u8 = 255;
-    const MAX_B: u8 = 255;
-
-    const BLACK: Self = Self::new(0, 0, 0);
-    const WHITE: Self = Self::new(255, 255, 255);
-
-    const RED: Self = Self::new(255, 0, 0);
-    const GREEN: Self = Self::new(0, 255, 0);
-    const BLUE: Self = Self::new(0, 0, 255);
-
-    const YELLOW: Self = Self::new(255, 0, 0);
-    const CYAN: Self = Self::new(0, 255, 0);
-    const MAGENTA: Self = Self::new(0, 0, 255);
-}
-
-impl PixelColor for RGB8 {
-    type Raw = RawU8;
-}
-
-impl FromColorUnclamped<Hsv<Srgb, u8>> for RGB8 {
-    fn from_color_unclamped(hsv: Hsv<Srgb, u8>) -> RGB8 {
-        if hsv.saturation == 0 {
-            return RGB8::new(hsv.value, hsv.value, hsv.value);
-        }
-
-        let region = hsv.hue.into_inner() / 43;
-        let remainder = (hsv.hue.into_inner() - (region * 43)) * 6;
-
-        let p = hsv.value.wrapping_mul(255 - hsv.saturation).wrapping_shr(8);
-        let q = (hsv.value.wrapping_mul(255 - ((hsv.saturation.wrapping_mul(remainder)).wrapping_shr(8)))).wrapping_shr(8);
-        let t = (hsv.value.wrapping_mul(255 - ((hsv.saturation.wrapping_mul(255 - remainder)).wrapping_shr(8)))).wrapping_shr(8);
-
-        match region {
-            0 => RGB8::new(hsv.value, t, p),
-            1 => RGB8::new(q, hsv.value, p),
-            2 => RGB8::new(p, hsv.value, t),
-            3 => RGB8::new(p, q, hsv.value),
-            4 => RGB8::new(t, p, hsv.value),
-            _ => RGB8::new(hsv.value, p, q)
-        }
-    }
-}

src/lib8/interpolate.rs

@@ -0,0 +1,98 @@
+use num::PrimInt;
+use core::ops::BitOr;
+
+use rgb::Rgb;
+
+pub type Fract8 = u8;
+
+pub trait Fract8Ops {
+    fn scale8(self, scale: Fract8) -> Self;
+    fn blend8(self, other: Self, scale: Fract8) -> Self;
+}
+
+impl Fract8Ops for u8 {
+    fn scale8(self, scale: Fract8) -> Self {
+        // borrowed from FastLED
+        (self as u16 * (1 + scale as u16)).unsigned_shr(8) as u8
+    }
+
+    fn blend8(self, other: Self, scale: Fract8) -> Self {
+        ((((self as u16).unsigned_shl(8).bitor(other as u16)) as u16).wrapping_add(other as u16 * scale as u16).wrapping_sub(self as u16 * scale as u16)).unsigned_shr(8) as u8
+    }
+}
+
+impl Fract8Ops for Rgb<u8> {
+    fn scale8(self, scale: Fract8) -> Self {
+        Rgb::new(
+            self.r.scale8(scale),
+            self.g.scale8(scale),
+            self.b.scale8(scale)
+        )
+    }
+
+    fn blend8(self, other: Self, scale: Fract8) -> Self {
+        match (other.r, other.g, other.b) {
+            (0, 0, 0) => self,
+            _ => Rgb::new(
+                self.r.blend8(other.r, scale),
+                self.g.blend8(other.g, scale),
+                self.b.blend8(other.b, scale)
+            )
+        }
+    }
+}
+
+pub fn scale8<T: Fract8Ops>(i: T, scale: Fract8) -> T {
+    i.scale8(scale)
+}
+
+pub fn avg7(i: i8, j: i8) -> i8 {
+    i.unsigned_shr(1).wrapping_add(j.unsigned_shr(1)).wrapping_add(i & 0x1)
+}
+
+pub fn grad8(hash: u8, x: i8, y: i8) -> i8 {
+    let mut u: i8;
+    let mut v: i8;
+
+    if hash & 4 != 0 {
+        u = y; v = x;
+    } else {
+        u = x; v = y;
+    }
+
+    if hash & 1 != 0 {
+        u = u.wrapping_neg();
+    }
+    if hash & 2 != 0 {
+        v = v.wrapping_neg();
+    }
+
+    return avg7(u, v);
+}
+
+pub fn lerp7by8(a: i8, b: i8, frac: u8) -> i8 {
+    if b > a {
+        let delta: u8 = b.wrapping_sub(a) as u8;
+        let scaled: u8 = scale8(delta, frac);
+        return a.wrapping_add(scaled as i8);
+    } else {
+        let delta: u8 = a.wrapping_sub(b) as u8;
+        let scaled: u8 = scale8(delta, frac);
+        return a.wrapping_sub(scaled as i8);
+    }
+}
+
+pub fn ease8InOutQuad(i: u8) -> u8 {
+    let j = if i & 0x80 != 0 {
+        255 - i
+    } else {
+        i
+    };
+    let jj = scale8(j, j);
+    let jj2 = jj.unsigned_shl(1);
+    if i & 0x80 == 0 {
+        return jj2
+    } else {
+        return 255 - jj2;
+    }
+}

src/lib8/mod.rs

@@ -0,0 +1,55 @@
+pub mod interpolate;
+pub mod noise;
+pub mod trig;
+
+use palette::encoding::srgb::Srgb;
+
+use rgb::Rgb;
+
+use crate::lib8::interpolate::scale8;
+
+pub trait IntoRgb8 {
+    fn into_rgb8(self) -> Rgb<u8>;
+}
+
+impl IntoRgb8 for Rgb<u8> {
+    fn into_rgb8(self) -> Rgb<u8> {
+        self
+    }
+}
+
+impl IntoRgb8 for palette::Hsv<Srgb, u8> {
+    //TODO: Borrowed from FastLED
+    fn into_rgb8(self) -> Rgb<u8> {
+        const HSV_SECTION_3: u8 = 0x40;
+
+        if self.saturation == 0 {
+            return Rgb::new(self.value, self.value, self.value)
+        }
+
+        let mock_hue = scale8(191, self.hue.into_inner());
+        let value: u8 = self.value;
+        let saturation: u8 = self.saturation;
+        let invsat: u8 = 255 - saturation;
+        let brightness_floor: u8 = (value as u16 * invsat as u16 / 256) as u8;
+
+        let color_amplitude: u8 = value - brightness_floor;
+        let section: u8 = mock_hue / HSV_SECTION_3;
+        let offset: u8 = mock_hue % HSV_SECTION_3;
+
+        let rampup: u8 = offset;
+        let rampdown: u8 = (HSV_SECTION_3 - 1) - offset;
+
+        let rampup_amp_adj: u8 = (rampup as u16 * color_amplitude as u16 / 64) as u8;
+        let rampdown_amp_adj: u8 = (rampdown as u16 * color_amplitude as u16 / 64) as u8;
+
+        let rampup_adj_with_floor: u8 = rampup_amp_adj.saturating_add(brightness_floor);
+        let rampdown_adj_with_floor: u8 = rampdown_amp_adj.saturating_add(brightness_floor);
+
+        match section {
+            1 => Rgb::new(brightness_floor, rampdown_adj_with_floor, rampup_adj_with_floor),
+            0 => Rgb::new(rampdown_adj_with_floor, rampup_adj_with_floor, brightness_floor),
+            _ => Rgb::new(rampup_adj_with_floor, brightness_floor, rampdown_adj_with_floor)
+        }
+    }
+}

src/lib8/noise.rs

@@ -0,0 +1,57 @@
+use crate::lib8::interpolate::*;
+
+const NOISE_CUBE: [u8; 257] = [
+    151, 160, 137,  91,  90,  15, 131,  13, 201,  95,  96,  53, 194, 233,   7, 225,
+140,  36, 103,  30,  69, 142,   8,  99,  37, 240,  21,  10,  23, 190,   6, 148,
+247, 120, 234,  75,   0,  26, 197,  62,  94, 252, 219, 203, 117,  35,  11,  32,
+57, 177,  33,  88, 237, 149,  56,  87, 174,  20, 125, 136, 171, 168,  68, 175,
+74, 165,  71, 134, 139,  48,  27, 166,  77, 146, 158, 231,  83, 111, 229, 122,
+60, 211, 133, 230, 220, 105,  92,  41,  55,  46, 245,  40, 244, 102, 143,  54,
+65,  25,  63, 161,   1, 216,  80,  73, 209,  76, 132, 187, 208,  89,  18, 169,
+200, 196, 135, 130, 116, 188, 159,  86, 164, 100, 109, 198, 173, 186,   3,  64,
+52, 217, 226, 250, 124, 123,   5, 202,  38, 147, 118, 126, 255,  82,  85, 212,
+207, 206,  59, 227,  47,  16,  58,  17, 182, 189,  28,  42, 223, 183, 170, 213,
+119, 248, 152,   2,  44, 154, 163,  70, 221, 153, 101, 155, 167,  43, 172,   9,
+129,  22,  39, 253,  19,  98, 108, 110,  79, 113, 224, 232, 178, 185, 112, 104,
+218, 246,  97, 228, 251,  34, 242, 193, 238, 210, 144,  12, 191, 179, 162, 241,
+81,  51, 145, 235, 249,  14, 239, 107,  49, 192, 214,  31, 181, 199, 106, 157,
+184,  84, 204, 176, 115, 121,  50,  45, 127,   4, 150, 254, 138, 236, 205,  93,
+222, 114,  67,  29,  24,  72, 243, 141, 128, 195,  78,  66, 215,  61, 156, 180,
+151];
+
+const fn get_cube(x: u8) -> u8 {
+    NOISE_CUBE[x as usize]
+}
+
+fn inoise8_raw(x_src: u16, y_src: u16) -> i8 {
+    let x = x_src.wrapping_shr(8) as u8;
+    let y = y_src.wrapping_shr(8) as u8;
+
+    let a  = get_cube(x) + y;
+    let aa = get_cube(a);
+    let ab = get_cube(a+1);
+    let b = get_cube(x+1) + y;
+    let ba = get_cube(b);
+    let bb = get_cube(b+1);
+
+    let mut u = x_src as u8;
+    let mut v = y_src as u8;
+
+    let xx = ((x_src as u8).wrapping_shr(1) & 0x7f) as i8;
+    let yy = ((y_src as u8).wrapping_shr(1) & 0x7f) as i8;
+    let n = 0x80u8 as i8;
+
+    u = ease8InOutQuad(u);
+    v = ease8InOutQuad(v);
+
+    let x1 = lerp7by8(grad8(get_cube(aa), xx, yy), grad8(get_cube(ba), xx.wrapping_sub(n), yy), u);
+    let x2 = lerp7by8(grad8(get_cube(ab), xx, yy.wrapping_sub(n)), grad8(get_cube(bb), xx.wrapping_sub(n), yy.wrapping_sub(n)), u);
+
+    return lerp7by8(x1, x2, v);
+}
+
+pub fn inoise8(x: i16, y: i16) -> u8 {
+    let mut n = inoise8_raw(x as u16, y as u16);
+    n = n.wrapping_add(64);
+    return (n as u8).saturating_add(n as u8);
+}

src/lib8/trig.rs

@@ -0,0 +1,57 @@
+use num::PrimInt;
+
+const B_M16_INTERLEAVE: [u8; 8] = [0, 49, 49, 41, 90, 27, 117, 10];
+
+pub trait Trig8 {
+    fn sin8(self) -> u8;
+    fn cos8(self) -> u8;
+}
+
+impl Trig8 for u8 {
+    fn sin8(self) -> u8 {
+        let mut offset: u8 = self;
+        if self & 0x40 != 0 {
+            offset = 255 - offset;
+        }
+        offset &= 0x3f;
+
+        let mut secoffset: u8 = offset & 0x0f;
+        if self & 0x40 != 0 {
+            secoffset += 1;
+        }
+
+        let section: u8 = offset.unsigned_shr(4);
+        let s2: u8 = section * 2;
+        let b: u8 = B_M16_INTERLEAVE[s2 as usize];
+        let m16: u8 = B_M16_INTERLEAVE[s2 as usize + 1];
+        let mx: u8 = m16.wrapping_mul(secoffset).unsigned_shr(4);
+        let mut y: i8 = mx as i8 + b as i8;
+        if self & 0x80 != 0 {
+            y = -y;
+        }
+        y = y.wrapping_add(128u8 as i8);
+        return y as u8;
+    }
+
+    fn cos8(self) -> u8 {
+        sin8(self.wrapping_add(64))
+    }
+}
+
+impl Trig8 for usize {
+    fn sin8(self) -> u8 {
+        ((self % 255) as u8).sin8()
+    }
+
+    fn cos8(self) -> u8 {
+        ((self % 255) as u8).cos8()
+    }
+}
+
+pub fn sin8<T: Trig8>(theta: T) -> u8 {
+    theta.sin8()
+}
+
+pub fn cos8<T: Trig8>(theta: T) -> u8 {
+    theta.cos8()
+}

src/main.rs

@@ -1,87 +1,48 @@
-use palette::Hsv;
-use palette::convert::IntoColorUnclamped;
-
-use ws2812_esp32_rmt_driver::lib_smart_leds::Ws2812Esp32Rmt;
-use ws2812_esp32_rmt_driver::lib_embedded_graphics::Ws2812DrawTarget;
-
 mod power;
 mod lib8;
 mod render;
 mod task;
 mod time;
 mod geometry;
-mod embedded_graphics_lib;
-mod smart_leds_lib;
 mod platform;
+mod animations;
+mod mappings;
+mod buffers;
 
-use crate::time::Periodically;
-use crate::geometry::{Coordinates, VirtualCoordinates};
-use crate::render::{Shader, Surfaces, Surface, SimpleSurface};
-use crate::task::Task;
-use crate::platform::{DisplayInit, PonderjarTarget, SPIDisplay};
-
-struct IdleTask<T: Surface> {
-    frame: u8,
-    surface: T,
-    updater: Periodically
-}
-
-struct IdleShader {
-    frame: u8
-}
-
-impl Shader for IdleShader {
-    fn draw(&self, coords: VirtualCoordinates) -> lib8::RGB8 {
-        Hsv::new_srgb(self.frame.wrapping_add(coords.x()).wrapping_add(coords.y()), 255, 255).into_color_unclamped()
-    }
-}
-
-impl<T: Surface> IdleTask<T> {
-    fn new(surface: T) -> Self {
-        IdleTask {
-            frame: 0,
-            surface: surface,
-            updater: Periodically::new_every_n_ms(16)
-        }
-    }
-}
-
-impl<T: Surface> Task for IdleTask<T> {
-    fn name(&self) -> &'static str { "Idle" }
-
-    fn tick(&mut self) {
-        self.updater.run(|| {
-            self.frame = self.frame.wrapping_add(1);
-            self.surface.set_shader(Box::new(IdleShader { frame: self.frame }));
-        })
-    }
-
-    fn stop(&mut self) {
-        self.surface.clear_shader();
-    }
-}
+use crate::platform::{DefaultBoard, Board};
+use crate::task::{FixedSizeScheduler, Scheduler};
+use crate::render::{Surfaces, Renderer};
+use crate::geometry::Rectangle;
 
 fn main() {
-    // It is necessary to call this function once. Otherwise some patches to the runtime
-    // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
-    esp_idf_svc::sys::link_patches();
+    let mut board: DefaultBoard = Board::take();
 
-    // Bind the log crate to the ESP Logging facilities
-    esp_idf_svc::log::EspLogger::initialize_default();
+    log::info!("Board: {}", core::any::type_name_of_val(&board));
 
-    log::info!("Setting up display");
-    //let mut display = SPIDisplay::new_display::<SimpleSurface>();
-    //let mut display = PonderjarTarget::new_display::<SimpleSurface>();
-    let mut display = Ws2812Esp32Rmt::new_display::<SimpleSurface>();
+    log::info!("Creating tasks");
+    let mut system = board.system_tasks();
+    log::info!("System scheduler: {}", core::any::type_name_of_val(&system));
 
-    log::info!("Creating runner");
-    let mut runner = task::Scheduler::new(vec![
-        Box::new(IdleTask::new(display.new_surface().unwrap())),
-        Box::new(display),
+    log::info!("Creating output");
+    let output = board.output();
+    log::info!("Output: {}", core::any::type_name_of_val(&output));
+
+    log::info!("Preparing surfaces");
+    let mut surfaces = board.surfaces();
+    log::info!("Surface implementation: {}", core::any::type_name_of_val(&output));
+
+    log::info!("Creating animations");
+    let mut animations = FixedSizeScheduler::new([
+        Box::new(animations::IdleTask::new(&mut surfaces)),
+        Box::new(animations::TestPattern::new(surfaces.new_surface(&Rectangle::everything()).unwrap())),
     ]);
 
+    let mut renderer = FixedSizeScheduler::new([Box::new(Renderer::new(output, surfaces))]);
+
     log::info!("Ready to rock and roll");
     loop {
-        runner.tick();
+        animations.tick();
+        system.tick();
+        renderer.tick();
     }
 }

src/mappings.rs

@@ -0,0 +1,331 @@
+use crate::buffers::Pixbuf;
+use crate::geometry::*;
+
+use crate::lib8::interpolate::scale8;
+use crate::render::PixelView;
+
+use core::cmp::{max, min};
+use core::fmt::{Formatter, Debug};
+
+pub trait CoordinateView<'a>: Debug {
+    type Space: CoordinateSpace;
+    fn next(&mut self) -> Option<(Coordinates<Virtual>, Coordinates<Self::Space>)>;
+}
+
+pub trait Select<'a> {
+    type Space: CoordinateSpace;
+    type View: CoordinateView<'a>;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View;
+}
+
+#[derive(Debug)]
+pub struct LinearCoordView {
+    rect: Rectangle<Virtual>,
+    idx: usize,
+}
+
+pub struct LinearSpace {}
+impl CoordinateSpace for LinearSpace {
+    type Data = usize;
+}
+
+pub type LinearCoords = Coordinates<LinearSpace>;
+
+impl<'a> CoordinateView<'a> for LinearCoordView {
+    type Space = LinearSpace;
+    fn next(&mut self) -> Option<(VirtualCoordinates, LinearCoords)> {
+        if self.idx as u8 == self.rect.bottom_right.x {
+            None
+        } else {
+            let virt = VirtualCoordinates::new(self.idx as u8, 0); // FIXME: scale8
+            let phys = LinearCoords::new(
+                self.idx as usize,
+                0
+            );
+            self.idx += 1;
+            return Some((virt, phys))
+        }
+    }
+}
+
+pub struct LinearPixelMapping {
+}
+
+impl LinearPixelMapping {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<'a> Select<'a> for LinearPixelMapping {
+    type Space = LinearSpace;
+    type View = LinearCoordView;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View {
+        LinearCoordView {
+            rect: rect.clone(),
+            idx: 0,
+        }
+    }
+}
+
+#[derive(Default, Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Stride {
+    pub length: u8,
+    pub x: u8,
+    pub y: u8,
+    pub reverse: bool,
+    pub physical_idx: usize
+}
+
+impl Stride {
+    pub const fn pixel_idx_for_offset(&self, offset: u8) -> usize {
+        if self.reverse {
+            self.physical_idx + (self.length + self.y - 1 - offset) as usize
+        } else {
+            self.physical_idx + offset as usize
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct StrideMapping<const STRIDE_NUM: usize = 24> {
+    pub strides: [Stride; STRIDE_NUM],
+    pub pixel_count: usize,
+    pub size: Rectangle<StrideSpace>
+}
+
+impl<const STRIDE_NUM: usize> StrideMapping<STRIDE_NUM> {
+    pub fn new() -> Self {
+        Self::from_json(&[
+            (0, 0, 255, false)
+        ])
+    }
+
+    pub fn new_jar() -> Self {
+        Self::from_json(&[
+            (0, 0, 17, false),
+            (1, 0, 17, false),
+            (2, 0, 17, false),
+            (3, 0, 17, false),
+            (4, 0, 16, false),
+            (5, 0, 17, false),
+            (6, 0, 17, false),
+            (7, 0, 17, false),
+            (8, 0, 17, false),
+            (9, 0, 17, false),
+            (10, 0, 17, false),
+            (11, 0, 17, false),
+            (12, 0, 18, false),
+            (13, 0, 17, false),
+            (14, 0, 18, false),
+            (15, 0, 17, false),
+            (16, 0, 17, false),
+            (17, 0, 17, false)
+        ])
+    }
+
+    pub fn new_panel() -> Self {
+        Self::from_json(&[
+            (0, 0, 16, false),
+            (1, 0, 16, true),
+            (2, 0, 16, false),
+            (3, 0, 16, true),
+            (4, 0, 16, false),
+            (5, 0, 16, true),
+            (6, 0, 16, false),
+            (7, 0, 16, true),
+            (8, 0, 16, false),
+            (9, 0, 16, true),
+            (10, 0, 16, false),
+            (11, 0, 16, true),
+            (12, 0, 16, false),
+            (13, 0, 16, true),
+            (14, 0, 16, false),
+            (15, 0, 16, true),
+        ])
+    }
+
+    pub fn from_json(stride_json: &[(u8, u8, u8, bool)]) -> Self {
+        let mut strides = [Stride::default(); STRIDE_NUM];
+        let stride_count = stride_json.len();
+        let mut physical_idx = 0;
+        let mut size: Option<Rectangle<StrideSpace>> = None;
+        for stride_idx in 0..stride_count {
+            let json_data = stride_json[stride_idx];
+            let x = json_data.0;
+            let y = json_data.1;
+            let length = json_data.2;
+            let reverse = json_data.3;
+            strides[stride_idx] = Stride {
+                length,
+                x,
+                y,
+                reverse,
+                physical_idx
+            };
+            physical_idx += length as usize;
+            size = Some(match size.take() {
+                None => Rectangle::new(
+                    Coordinates::new(x, y),
+                    Coordinates::new(x, y + length - 1),
+                ),
+                Some(s) => Rectangle::new(
+                    Coordinates::new(
+                        min(s.top_left.x, x),
+                        min(s.top_left.y, y)
+                    ),
+                    Coordinates::new(
+                        max(s.bottom_right.x, x),
+                        max(s.bottom_right.y, y + length - 1)
+                    )
+                )
+            });
+            log::info!("stride={:?} size={:?}", strides[stride_idx], size);
+        }
+        let s = size.take().unwrap();
+        log::info!("size={:?}", s);
+
+        log::info!("strides={:?}", strides);
+
+        Self {
+            strides,
+            pixel_count: physical_idx,
+            size: s
+        }
+    }
+}
+
+impl<'a> Select<'a> for StrideMapping {
+    type Space = StrideSpace;
+    type View = StrideView<'a>;
+    fn select(&'a self, rect: &Rectangle<Virtual>) -> Self::View {
+        StrideView::new(self, rect)
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct StrideSpace {}
+impl CoordinateSpace for StrideSpace {
+    type Data = u8;
+}
+pub type StrideCoords = Coordinates<StrideSpace>;
+
+pub struct StrideView<'a> {
+    pub map: &'a StrideMapping,
+    range: Rectangle<StrideSpace>,
+    cur: StrideCoords,
+    step_size: VirtualCoordinates
+}
+
+impl<'a> Debug for StrideView<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("StrideView")
+        .field("range", &self.range)
+        .field("step", &self.step_size)
+        .field("cur", &self.cur).finish()
+    }
+}
+
+impl<'a> StrideView<'a> {
+    fn new(map: &'a StrideMapping, rect: &Rectangle<Virtual>) -> Self {
+        // Zero-index shape of the pixel picking area
+        let range: Rectangle<StrideSpace> = Rectangle::new(
+            Coordinates::new(
+                scale8(map.size.width() as u8, rect.top_left.x) + map.size.left() as u8,
+                scale8(map.size.height() as u8, rect.top_left.y) + map.size.top() as u8
+            ),
+            Coordinates::new(
+                scale8(map.size.width() as u8, rect.bottom_right.x) + map.size.left() as u8,
+                scale8(map.size.height() as u8, rect.bottom_right.y) + map.size.top() as u8
+            )
+        );
+        //log::info!("rect={:?} map.size={:?} range={:?}", rect, map.size, range);
+        debug_assert!(
+            range.bottom_right.x <= map.size.width() as u8 &&
+            range.bottom_right.y <= map.size.height() as u8,
+            "the range for this view is out of bounds range={:?} rect={:?}, map_size={:?}",
+            range,
+            rect,
+            (map.size.width(), map.size.height())
+        );
+        let step_size = VirtualCoordinates::new(
+            u8::MAX / core::cmp::max(1, range.width()),
+            u8::MAX / core::cmp::max(1, range.height())
+            //scale8(255, std::cmp::max(1, range.bottom_right.x - range.top_left.x)),
+            //scale8(255, std::cmp::max(1, range.bottom_right.y - range.top_left.y))
+        );
+        debug_assert_ne!(step_size.x, 0);
+        debug_assert_ne!(step_size.y, 0);
+        return Self {
+            map,
+            range,
+            step_size,
+            cur: range.top_left
+        };
+    }
+}
+
+impl<'a> CoordinateView<'a> for StrideView<'a> {
+    type Space = StrideSpace;
+    fn next(&mut self) -> Option<(VirtualCoordinates, StrideCoords)> {
+        // Keep scanning until we reach the far right of the range
+        while self.cur.x <= self.range.bottom_right.x {
+            debug_assert!((self.cur.x as usize) < self.map.strides.len(), "stride out of bounds {:?}", self);
+            let cur_stride: &Stride = &self.map.strides[self.cur.x as usize];
+
+            // Skip ahead to the top of the current stride if we are starting from higher above.
+            if self.cur.y < cur_stride.y {
+                self.cur.y = cur_stride.y;
+            }
+
+            // If we are at the bottom of our rectangle, or our stride, go to the next stride.
+            if self.cur.y > self.range.bottom_right.y || self.cur.y > cur_stride.y + cur_stride.length - 1 {
+                self.cur.x += 1;
+                self.cur.y = self.range.top_left.y;
+                continue;
+            }
+
+            // By now, we must be safely somewhere inside our current stride
+            debug_assert!(self.cur.y <= cur_stride.y + cur_stride.length - 1, "coords={:?} out of bounds for stride={:?} view={:?}", self.cur, cur_stride, self);
+
+            // Move to the next coord and return
+            let physical_coords = self.cur;
+            self.cur.y += 1;
+
+            let virtual_coords = VirtualCoordinates::new(
+                (physical_coords.x as u8).saturating_mul(self.step_size.x),
+                (physical_coords.y as u8).saturating_mul(self.step_size.y)
+            );
+
+            return Some((virtual_coords,  physical_coords));
+        }
+
+        None
+    }
+}
+
+pub struct StrideSampler<'a, P: Pixbuf> {
+    pixbuf: &'a mut P,
+    selection: StrideView<'a>
+}
+
+impl<'a, P: Pixbuf> StrideSampler<'a, P> {
+    pub fn new(pixbuf: &'a mut P, selection: StrideView<'a>) -> Self {
+        StrideSampler {
+            pixbuf,
+            selection
+        }
+    }
+}
+
+impl<'a, P: Pixbuf> PixelView for StrideSampler<'a, P> {
+    type Pixel = P::Pixel;
+    fn next(&mut self) -> Option<(Coordinates<Virtual>, &mut Self::Pixel)> {
+        if let Some((virt, coords)) = self.selection.next() {
+            let idx = self.selection.map.strides[coords.x as usize].pixel_idx_for_offset(coords.y);
+            Some((virt, &mut self.pixbuf[idx]))
+        } else {
+            None
+        }
+    }
+}

src/platform.rs

@@ -1,102 +0,0 @@
-use esp_idf_svc::hal::{
-    prelude::*,
-    gpio::AnyIOPin,
-    spi::{
-        config::{Config, DriverConfig},
-        Dma,
-        SpiBusDriver,
-        SpiDriver,
-    }
-};
-
-use ws2812_spi::Ws2812;
-use ws2812_esp32_rmt_driver::lib_smart_leds::Ws2812Esp32Rmt;
-use ws2812_esp32_rmt_driver::lib_embedded_graphics::{LedPixelShape, Ws2812DrawTarget};
-
-use embedded_graphics::prelude::{Size, Point};
-
-use crate::smart_leds_lib::SmartLedDisplay;
-use crate::embedded_graphics_lib::EmbeddedDisplay;
-
-use crate::render::{Surface, Display};
-use crate::task::Task;
-
-pub trait DisplayInit {
-    fn new_display<S: Surface>() -> impl Display<S> + Task;
-}
-
-impl DisplayInit for Ws2812Esp32Rmt<'_> {
-    fn new_display<S: Surface>() -> impl Display<S> + Task {
-        let peripherals = Peripherals::take().unwrap();
-        let led_pin = peripherals.pins.gpio14;
-        let channel = peripherals.rmt.channel0;
-
-        const POWER_VOLTS : u32 = 5;
-        const POWER_MA : u32 = 500;
-        const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
-
-        let target = Self::new(channel, led_pin).unwrap();
-        return SmartLedDisplay::new(target, MAX_POWER_MW);
-    }
-}
-
-impl<Shape: LedPixelShape> DisplayInit for Ws2812DrawTarget<'_, Shape> {
-    fn new_display<S: Surface>() -> impl Display<S> + Task {
-        let peripherals = Peripherals::take().unwrap();
-        let led_pin = peripherals.pins.gpio14;
-        let channel = peripherals.rmt.channel0;
-
-        const POWER_VOLTS : u32 = 5;
-        const POWER_MA : u32 = 500;
-        const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
-
-        let target = Self::new(channel, led_pin).unwrap();
-        return EmbeddedDisplay::<Self, S>::new(target, MAX_POWER_MW);
-    }
-}
-
-pub struct SPIDisplay {}
-impl DisplayInit for SPIDisplay {
-    fn new_display<S: Surface>() -> impl Display<S> + Task {
-        let peripherals = Peripherals::take().unwrap();
-
-        let driver = SpiDriver::new_without_sclk(
-            peripherals.spi2,
-            peripherals.pins.gpio14,
-            Option::<AnyIOPin>::None,
-            &DriverConfig::new().dma(Dma::Auto(512))
-        ).unwrap();
-
-        let cfg = Config::new().baudrate(3_200.kHz().into());
-
-        let spi = SpiBusDriver::new(driver, &cfg).unwrap();
-
-        const POWER_VOLTS : u32 = 5;
-        const POWER_MA : u32 = 500;
-        const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
-        let target = Ws2812::new(spi);
-        return SmartLedDisplay::new(target, MAX_POWER_MW)
-    }
-}
-
-
-pub struct PonderjarMatrix {}
-impl LedPixelShape for PonderjarMatrix {
-    fn size() -> Size {
-        Size::new(17, 17)
-    }
-
-    fn pixel_index(point: Point) -> Option<usize> {
-        if (0..Self::size().width as i32).contains(&point.x) && (0..Self::size().height as i32).contains(&point.y) {
-            if point.y % 2 == 0 {
-                Some((point.y as u32 * Self::size().width as u32 + point.x as u32).try_into().unwrap())
-            } else {
-                Some((point.y as u32 * Self::size().width as u32 - point.x as u32).try_into().unwrap())
-            }
-        } else {
-            None
-        }
-    }
-}
-
-pub type PonderjarTarget<'a> = Ws2812DrawTarget<'a, PonderjarMatrix>;

src/platform/embedded_graphics_lib.rs

@@ -0,0 +1,145 @@
+use embedded_graphics::{
+    prelude::*,
+    pixelcolor::Rgb888,
+    primitives::Rectangle
+};
+use rgb::RGB8;
+use ws2812_esp32_rmt_driver::lib_embedded_graphics::{Ws2812DrawTarget, LedPixelShape};
+
+use esp_idf_svc::hal::prelude::Peripherals;
+
+use std::io;
+use std::fmt::{Formatter, Debug};
+
+use crate::power;
+use crate::power::AsMilliwatts;
+use crate::lib8::*;
+use crate::render::*;
+use crate::geometry::*;
+use crate::platform::DisplayInit;
+
+pub struct EmbeddedDisplay<T, S>
+where
+T: DrawTarget,
+S: Surface {
+    surfaces : SurfacePool<S>,
+    target: T,
+    total_mw: u32,
+    max_mw: u32,
+}
+
+
+impl<T: DrawTarget, S: Surface> Debug for EmbeddedDisplay<T, S> {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
+        f.debug_struct("EmbeddedDisplay")
+        .field("total_mw", &self.total_mw)
+        .field("surfaces", &self.surfaces)
+        .finish()
+    }
+}
+
+trait TargetInit<T: DrawTarget> {
+    fn setup_target(mut target: T) -> T { target }
+}
+
+impl<T, S> EmbeddedDisplay<T, S>
+where
+Self: TargetInit<T>,
+T: DrawTarget,
+S: Surface {
+    pub fn new(target: T, max_mw: u32) -> Self {
+        EmbeddedDisplay {
+            surfaces: SurfacePool::new(),
+            target: Self::setup_target(target),
+            max_mw: max_mw,
+            total_mw: 0,
+        }
+    }
+}
+
+impl<T: LedPixelShape, S: Surface> TargetInit<Ws2812DrawTarget<'_, T>> for EmbeddedDisplay<Ws2812DrawTarget<'_, T>, S> {
+    fn setup_target(mut target: Ws2812DrawTarget<'_, T>) -> Ws2812DrawTarget<'_, T> {
+        target.set_brightness(0);
+        target
+    }
+}
+
+impl<T, S> Surfaces<S> for EmbeddedDisplay<T, S>
+where
+T: DrawTarget,
+S: Surface {
+    fn new_surface(&mut self) -> Result<S, io::Error> {
+        self.surfaces.new_surface()
+    }
+}
+
+impl<T: LedPixelShape, S: Surface> Display<S> for EmbeddedDisplay<Ws2812DrawTarget<'_, T>, S> {
+
+    fn start_frame(&mut self) {
+        self.total_mw = 0;
+    }
+
+    fn end_frame(&mut self) {
+        let brightness = power::brightness_for_mw(self.total_mw, 255, self.max_mw);
+        self.target.set_brightness(brightness);
+        self.target.flush().unwrap();
+    }
+
+    fn render_frame(&mut self) {
+        let size = T::size();
+        let xStride: u8 = 255 / (size.width as u8);
+        let yStride: u8 = 255 / (size.height as u8);
+        let area = Rectangle::new(Point::new(0, 0), size);
+
+        self.target.draw_iter(
+            area.points()
+            .map(|pos| {
+                let virtCoords = VirtualCoordinates::new(pos.x as u8 * xStride, pos.y as u8 * yStride);
+                let mut pixel = RGB8::new(0, 0, 0);
+                for surface in self.surfaces.iter() {
+                    surface.with_shader(|shader| {
+                        pixel = pixel.saturating_add(shader.draw(virtCoords.clone()));
+                    })
+                }
+                self.total_mw += pixel.as_milliwatts();
+                return Pixel(pos, Rgb888::new(pixel.r, pixel.g, pixel.b));
+            })
+        ).unwrap();
+    }
+}
+
+impl<Shape: LedPixelShape> DisplayInit for Ws2812DrawTarget<'_, Shape> {
+    fn new_display<S: Surface>() -> impl Display<S> {
+        let peripherals = Peripherals::take().unwrap();
+        let led_pin = peripherals.pins.gpio14;
+        let channel = peripherals.rmt.channel0;
+
+        const POWER_VOLTS : u32 = 5;
+        const POWER_MA : u32 = 500;
+        const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
+
+        let target = Self::new(channel, led_pin).unwrap();
+        return EmbeddedDisplay::<Self, S>::new(target, MAX_POWER_MW);
+    }
+}
+
+pub struct PonderjarMatrix {}
+impl LedPixelShape for PonderjarMatrix {
+    fn size() -> Size {
+        Size::new(17, 17)
+    }
+
+    fn pixel_index(point: Point) -> Option<usize> {
+        if (0..Self::size().width as i32).contains(&point.x) && (0..Self::size().height as i32).contains(&point.y) {
+            if point.y % 2 == 0 {
+                Some((point.y as u32 * Self::size().width as u32 + point.x as u32).try_into().unwrap())
+            } else {
+                Some((point.y as u32 * Self::size().width as u32 - point.x as u32).try_into().unwrap())
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub type PonderjarTarget<'a> = Ws2812DrawTarget<'a, PonderjarMatrix>;

src/platform/esp32.rs

@@ -0,0 +1,312 @@
+use core::borrow::BorrowMut;
+use std::sync::Arc;
+use std::fmt::Debug;
+use std::sync::Mutex;
+
+use chrono::DateTime;
+use chrono::Utc;
+
+use esp_idf_svc::eventloop::{EspSubscription, EspSystemEventLoop, System};
+use esp_idf_svc::hal::modem::Modem;
+use esp_idf_svc::hal::prelude::Peripherals;
+use esp_idf_svc::hal::task::thread::ThreadSpawnConfiguration;
+use esp_idf_svc::netif::IpEvent;
+use esp_idf_svc::nvs::{EspDefaultNvsPartition, EspNvsPartition, NvsDefault};
+use esp_idf_svc::sntp::EspSntp;
+use esp_idf_svc::sys::esp_efuse_mac_get_default;
+use esp_idf_svc::wifi::{AuthMethod, ClientConfiguration, Configuration, EspWifi, WifiEvent};
+use rgb::Rgb;
+
+use super::smart_leds_lib::rmt::FastWs2812Esp32Rmt;
+use super::smart_leds_lib::StrideOutput;
+use super::Board;
+
+use crate::buffers::BufferedSurfacePool;
+use crate::buffers::Pixbuf;
+use crate::mappings::StrideMapping;
+use crate::task::FixedSizeScheduler;
+use crate::task::Task;
+use crate::time::Periodically;
+
+pub mod i2s {
+    use esp_idf_svc::hal::i2s::*;
+    use rgb::ComponentBytes;
+    use rgb::Rgb;
+    
+    use crate::mappings::*;
+    use crate::buffers::Pixbuf;
+    use crate::render::Output;
+    use crate::render::Sample;
+
+    pub struct I2SOutput<'d> {
+        driver: I2sDriver<'d, I2sTx>,
+        pixbuf: [Rgb<u8>; 310],
+        pixmap: StrideMapping,
+    }
+
+    impl<'d> I2SOutput<'d> {
+        fn new(driver: I2sDriver<'d, I2sTx>) -> Self {
+            I2SOutput {
+                driver,
+                pixbuf: Pixbuf::new(),
+                pixmap: StrideMapping::new_jar()
+            }
+        }
+    }
+
+    impl<'d> Output for I2SOutput<'d> {
+        fn blank(&mut self) {
+            self.pixbuf.blank();
+        }
+
+        fn commit(&mut self) {
+            let bytes = self.pixbuf.as_bytes();
+            let mut written = self.driver.preload_data(bytes).unwrap();
+            self.driver.tx_enable().unwrap();
+            while written < bytes.len() {
+                let next = &bytes[written..];
+                written += self.driver.write(next, 0).unwrap();
+            }
+            self.driver.tx_disable().unwrap();
+        }
+    }
+
+    impl<'d> Sample for I2SOutput<'d> {
+        type Pixel = Rgb<u8>;
+        fn sample(&mut self, rect: &crate::geometry::Rectangle<crate::geometry::Virtual>) -> impl crate::render::PixelView<Pixel = Self::Pixel> {
+            StrideSampler::new(&mut self.pixbuf, self.pixmap.select(rect))
+        }
+    }
+}
+
+pub struct Esp32Board {
+    sys_loop: EspSystemEventLoop,
+    modem: Option<Modem>,
+    surfaces: BufferedSurfacePool,
+    output: Option<<Self as Board>::Output>
+}
+
+impl Board for Esp32Board {
+    type Output = StrideOutput<[Rgb<u8>; 310], FastWs2812Esp32Rmt<'static>>;
+    type Surfaces = BufferedSurfacePool;
+    type Scheduler = FixedSizeScheduler<2>;
+    
+    fn take() -> Self {
+        // It is necessary to call this function once. Otherwise some patches to the runtime
+        // implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
+        esp_idf_svc::sys::link_patches();
+
+        // Bind the log crate to the ESP Logging facilities
+        esp_idf_svc::log::EspLogger::initialize_default();
+
+        let peripherals = Peripherals::take().unwrap();
+        let sys_loop = EspSystemEventLoop::take().unwrap();
+
+        let mut chip_id: [u8; 8] = [0; 8];
+        unsafe {
+            esp_efuse_mac_get_default(&mut chip_id as *mut u8);
+        }
+
+        log::info!("Setting up output for chip ID {:x?}", chip_id);
+
+        const POWER_VOLTS : u32 = 5;
+        const POWER_MA : u32 = 500;
+        const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
+        let pins = peripherals.pins;
+
+        ThreadSpawnConfiguration {
+            pin_to_core: Some(esp_idf_svc::hal::cpu::Core::Core1),
+            ..Default::default()
+        }.set().unwrap();
+        // Wifi driver creates too many interrupts on core0, so we need to use RMT on core1.
+        // But the implementation spawns a thread based on the core the driver was created in,
+        // so we create the driver in another thread briefly.
+        // Fun stuff.
+        let output = match chip_id {
+            [72, 202, 67, 89, 145, 204, 0, 0] => {
+                StrideOutput::new(
+                    Pixbuf::new(),
+                    StrideMapping::new_panel(), 
+                    std::thread::spawn(move || { FastWs2812Esp32Rmt::new(peripherals.rmt.channel0, pins.gpio5).unwrap() }).join().unwrap(),
+                    MAX_POWER_MW
+                )
+            },
+            [0x8C, 0xAA, 0xB5, 0x83, 0x5f, 0x74, 0x0, 0x0] => {
+                StrideOutput::new(
+                    Pixbuf::new(),
+                    StrideMapping::new_jar(),
+                    std::thread::spawn(move || { FastWs2812Esp32Rmt::new(peripherals.rmt.channel0, pins.gpio14).unwrap() }).join().unwrap(),
+                    MAX_POWER_MW
+                )
+            },
+            _ => {
+                StrideOutput::new(
+                    Pixbuf::new(),
+                    StrideMapping::new(), 
+                    std::thread::spawn(move || { FastWs2812Esp32Rmt::new(peripherals.rmt.channel0, pins.gpio5).unwrap() }).join().unwrap(),
+                    MAX_POWER_MW
+                )
+            }
+        };
+        ThreadSpawnConfiguration {
+            ..Default::default()
+        }.set().unwrap();
+
+        Esp32Board {
+            modem: Some(peripherals.modem),
+            sys_loop: sys_loop.clone(),
+            surfaces: BufferedSurfacePool::new(),
+            output: Some(output)
+        }
+    }
+
+    fn output(&mut self) -> Self::Output {
+        self.output.take().unwrap()
+    }
+
+    fn surfaces(&mut self) -> Self::Surfaces {
+        self.surfaces.clone()
+    }
+
+    fn system_tasks(&mut self) -> Self::Scheduler {
+        let nvs = EspDefaultNvsPartition::take().unwrap();
+        FixedSizeScheduler::new([
+            Box::new(WifiTask::new(self.modem.take().unwrap(), self.sys_loop.clone(), &nvs)),
+            Box::new(self.surfaces.clone())
+        ])
+    }
+}
+
+impl Debug for WifiTask {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WifiTask").finish()
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum WifiState {
+    Stopped,
+    Disconnected,
+    Connecting,
+    Connected
+}
+
+struct WifiTask {
+    wifi: EspWifi<'static>,
+    ntp: EspSntp<'static>,
+    connection_check: Periodically,
+    state: Arc<Mutex<WifiState>>,
+    last_state: WifiState,
+    sys_loop: EspSystemEventLoop,
+    wifi_sub: Option<EspSubscription<'static, System>>,
+    ip_sub: Option<EspSubscription<'static, System>>
+}
+
+impl WifiTask {
+    fn new(modem: Modem, sys_loop: EspSystemEventLoop, nvs: &EspNvsPartition<NvsDefault>) -> Self {
+        log::info!("Installing wifi driver");
+        let mut wifi = EspWifi::new(
+            modem,
+            sys_loop.clone(),
+            Some(nvs.clone())
+        ).unwrap();
+        let wifi_config = Configuration::Client(ClientConfiguration {
+            ssid: "The Frequency".try_into().unwrap(),
+            bssid: None,
+            auth_method: AuthMethod::WPA2Personal,
+            password: "thepasswordkenneth".try_into().unwrap(),
+            channel: None,
+            ..Default::default()
+        });
+        wifi.set_configuration(&wifi_config).unwrap();
+
+        WifiTask {
+            wifi,
+            ntp: EspSntp::new_default().unwrap(),
+            connection_check: Periodically::new_every_n_seconds(1),
+            state: Arc::new(Mutex::new(WifiState::Stopped)),
+            last_state: WifiState::Stopped,
+            sys_loop,
+            wifi_sub: None,
+            ip_sub: None
+        }
+    }
+
+    fn connect(&mut self) {
+        log::info!("Connecting wifi");
+        self.wifi.start().unwrap();
+        self.wifi.connect().unwrap();
+    }
+
+    fn disconnect(&mut self) {
+        log::info!("Disconnecting wifi");
+        self.wifi.disconnect().unwrap();
+        self.wifi.stop().unwrap();
+    }
+}
+
+impl Task for WifiTask {
+    fn start(&mut self) {
+        log::info!("Starting wifi!");
+
+        let wifi_state = self.state.clone();
+        self.wifi_sub = Some(self.sys_loop.subscribe::<WifiEvent, _>( move |evt| {
+            log::warn!("wifi event {:?}", evt);
+            let next_state = match evt {
+                WifiEvent::StaStopped => Some(WifiState::Disconnected),
+                WifiEvent::StaDisconnected => Some(WifiState::Disconnected),
+                WifiEvent::StaStarted => Some(WifiState::Connecting),
+                WifiEvent::StaConnected => Some(WifiState::Connecting),
+                _ => None
+            };
+
+            match next_state {
+                Some(s) => {
+                    let mut state = wifi_state.lock().unwrap();
+                    *state = s
+                },
+                None => ()
+            }
+        }).unwrap());
+        let ip_state = self.state.clone();
+        self.ip_sub = Some(self.sys_loop.subscribe::<IpEvent, _>(move |evt| {
+            log::warn!("ip event {:?}", evt);
+            match evt {
+                IpEvent::DhcpIpAssigned(_) => {
+                    let mut state = ip_state.lock().unwrap();
+                    *state = WifiState::Connected;
+                },
+                _ => ()
+            }
+        }).unwrap());
+
+        self.connect();
+    }
+
+    fn tick(&mut self ) {
+        if self.connection_check.tick() {
+            let cur_state = *self.state.lock().unwrap();
+
+            if self.last_state != cur_state {
+                match cur_state {
+                    WifiState::Connected => log::info!("Wifi connected!"),
+                    WifiState::Connecting => log::info!("Connecting!"),
+                    WifiState::Stopped => log::info!("Stopped!"),
+                    WifiState::Disconnected => log::info!("Disconnected!")
+                }
+
+                log::info!("online: {:?}", cur_state);
+
+                self.last_state = cur_state;
+            }
+
+            let now: DateTime<Utc> = std::time::SystemTime::now().into();
+            log::info!("Current time: {} status={:?}", now.format("%d/%m/%Y %T"), self.ntp.get_sync_status());
+        }
+    }
+
+    fn stop(&mut self) {
+        log::info!("Stopping wifi");
+        self.disconnect();
+    }
+}

src/platform/mod.rs

@@ -0,0 +1,23 @@
+#[cfg(feature="embedded-graphics")]
+pub mod embedded_graphics_lib;
+
+#[cfg(feature="smart-leds")]
+pub mod smart_leds_lib;
+
+pub mod esp32;
+
+pub type DefaultBoard = esp32::Esp32Board;
+
+use crate::render::{Output, Surfaces};
+use crate::task::Scheduler;
+
+pub trait Board {
+    type Output: Output;
+    type Surfaces: Surfaces;
+    type Scheduler: Scheduler;
+
+    fn take() -> Self;
+    fn output(&mut self) -> Self::Output;
+    fn surfaces(&mut self) -> Self::Surfaces;
+    fn system_tasks(&mut self) -> Self::Scheduler;
+}

src/platform/smart_leds_lib.rs

@@ -0,0 +1,156 @@
+use smart_leds_trait::SmartLedsWrite;
+
+use crate::buffers::Pixbuf;
+use crate::render::{HardwarePixel, Output, PixelView, Sample};
+use crate::power::brightness_for_mw;
+use crate::geometry::*;
+use crate::mappings::*;
+
+use core::fmt::Debug;
+
+impl<P: Pixbuf, T: FastWrite> Debug for StrideOutput<P, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("StrideOutput").finish()
+    }
+}
+
+pub struct StrideOutput<P: Pixbuf, T: FastWrite> {
+    pixbuf: P,
+    stride_map: StrideMapping,
+    target: T,
+    max_mw: u32
+}
+
+impl<P: Pixbuf, T: FastWrite> StrideOutput<P, T> {
+    pub fn new(pixbuf: P, stride_map: StrideMapping, target: T, max_mw: u32) -> Self {
+        assert!(stride_map.pixel_count <= pixbuf.pixel_count(), "map needs {} pixels, I only have PIXEL_NUM={}", stride_map.pixel_count, pixbuf.pixel_count());
+        StrideOutput {
+            pixbuf,
+            stride_map,
+            target,
+            max_mw
+        }
+    }
+}
+
+impl<P: Pixbuf, T: FastWrite> Sample for StrideOutput<P, T> {
+    type Pixel = P::Pixel;
+    fn sample(&mut self, rect: &Rectangle<Virtual>) -> impl PixelView<Pixel = Self::Pixel> {
+        StrideSampler::new(&mut self.pixbuf,self.stride_map.select(rect))
+    }
+}
+
+impl<P: Pixbuf<Pixel=T::Color>, T: FastWrite> Output for StrideOutput<P, T> {
+    fn blank(&mut self) {
+        self.pixbuf.blank();
+    }
+
+    fn commit(&mut self) {
+        let b = brightness_for_mw(self.pixbuf.as_milliwatts(), 255, self.max_mw);
+        if self.target.fast_write(self.pixbuf.iter_with_brightness(b)).is_err() {
+            panic!("Could not write frame!");
+        };
+    }
+}
+
+pub trait FastWrite: Send {
+    type Target: SmartLedsWrite;
+    type Color: HardwarePixel;
+    type Error;
+    fn fast_write<T, I>(&mut self, iterator: T) -> Result<(), Self::Error> where
+    T: IntoIterator<Item = I>,
+    I: Into<Self::Color>,
+    <T as IntoIterator>::IntoIter: Send;
+}
+
+#[cfg(feature="rmt")]
+pub mod rmt {
+    use ws2812_esp32_rmt_driver::driver::color::LedPixelColorGrb24;
+    use smart_leds::SmartLedsWrite;
+    use rgb::Rgb;
+    use ws2812_esp32_rmt_driver::LedPixelEsp32Rmt;
+
+    use super::FastWrite;
+
+    pub type FastWs2812Esp32Rmt<'a> = LedPixelEsp32Rmt<'a, Rgb<u8>, LedPixelColorGrb24>;
+
+    impl FastWrite for FastWs2812Esp32Rmt<'_> {
+        type Color = <Self as SmartLedsWrite>::Color;
+        type Error = <Self as SmartLedsWrite>::Error;
+        type Target = Self;
+        fn fast_write<T, I>(&mut self, iterator: T) -> Result<(), Self::Error> where
+            T: IntoIterator<Item = I>,
+            I: Into<Self::Color>,
+            <T as IntoIterator>::IntoIter: Send {
+                self.write_nocopy(iterator)
+        }
+    }
+}
+
+#[cfg(feature="spi")]
+pub mod spi {
+    use smart_leds::SmartLedsWrite;
+    use ws2812_spi::prerendered::Ws2812;
+
+    use crate::render::{Display, Surface};
+    use crate::platform::smart_leds_lib::SmartLedDisplay;
+    use crate::DisplayInit;
+    use super::FastWrite;
+
+    use esp_idf_svc::hal::{
+        prelude::*,
+        gpio::AnyIOPin,
+        spi::{
+            config::{Config, DriverConfig},
+            Dma,
+            SpiBusDriver,
+            SpiDriver,
+        }
+    };
+
+    impl<'a> FastWrite for Ws2812<'_, SpiBusDriver<'a, SpiDriver<'a>>> {
+        type Color = <Self as SmartLedsWrite>::Color;
+        type Error = <Self as SmartLedsWrite>::Error;
+        type Target = Self;
+
+        fn fast_write<T, I>(&mut self, iterator: T) -> Result<(), Self::Error> where
+            T: IntoIterator<Item = I>,
+            I: Into<Self::Color>,
+            <T as IntoIterator>::IntoIter: Send {
+                let resp = self.write(iterator);
+                if let Err(e) = resp {
+                    panic!("Could not write SPI frame! {:?}", e)
+                } else {
+                    resp
+                }
+        }
+    }
+
+    static mut STATIC_BUFFER: [u8; 400 * 12] = [0; 400 * 12];
+
+    pub struct SPIDisplay {}
+    impl DisplayInit for SPIDisplay {
+        fn new_display<S: Surface>() -> impl Display<S> {
+            let peripherals = Peripherals::take().unwrap();
+
+            let driver = SpiDriver::new_without_sclk(
+                peripherals.spi2,
+                peripherals.pins.gpio5,
+                Option::<AnyIOPin>::None,
+                &DriverConfig::new().dma(Dma::Auto(4092))
+            ).unwrap();
+
+            let cfg = Config::new().baudrate(3.MHz().into());
+
+            let spi = SpiBusDriver::new(driver, &cfg).unwrap();
+
+            const POWER_VOLTS : u32 = 5;
+            const POWER_MA : u32 = 500;
+            const MAX_POWER_MW : u32 = POWER_VOLTS * POWER_MA;
+            unsafe {
+                let target = Ws2812::new(spi, &mut STATIC_BUFFER);
+                return SmartLedDisplay::<Ws2812<SpiBusDriver<'_, SpiDriver<'_>>>, S, 310>::new(target, MAX_POWER_MW);
+            }
+        }
+    }
+}

src/power.rs

@@ -1,7 +1,37 @@
+use rgb::RGB8;
+
 pub trait AsMilliwatts {
     fn as_milliwatts(&self) -> u32;
 }
 
+impl AsMilliwatts for RGB8 {
+    fn as_milliwatts(&self) -> u32 {
+        const RED_MW : u32   = 16 * 5; //< 16mA @ 5v = 80mW
+        const GREEN_MW : u32 = 11 * 5; //< 11mA @ 5v = 55mW
+        const BLUE_MW : u32  = 15 * 5; //< 15mA @ 5v = 75mW
+        const DARK_MW : u32  =      5; //<  1mA @ 5v =  5mW
+
+        let red = (self.r as u32 * RED_MW).wrapping_shr(8);
+        let green = (self.g as u32 * GREEN_MW).wrapping_shr(8);
+        let blue = (self.b as u32 * BLUE_MW).wrapping_shr(8);
+
+        return red + green + blue + DARK_MW;
+    }
+}
+
+impl<T> AsMilliwatts for [T] where T: AsMilliwatts {
+    fn as_milliwatts(&self) -> u32 {
+        self.iter().map(|p| { p.as_milliwatts() }).sum()
+    }
+}
+
+
+impl<T, const S: usize> AsMilliwatts for [T; S] where T: AsMilliwatts {
+    fn as_milliwatts(&self) -> u32 {
+        self.iter().map(|p| { p.as_milliwatts() }).sum()
+    }
+}
+
 pub fn brightness_for_mw(total_mw : u32, target : u8, max_power: u32) -> u8 {
     let target32 = target as u32;
     let requested_mw = (total_mw * target32) / 256;

src/render.rs

@@ -1,127 +1,86 @@
-use std::rc::Rc;
-use std::cell::RefCell;
-use std::sync::{Arc, Mutex};
-use std::io;
+use rgb::Rgb;
 
-use crate::lib8::RGB8;
 use crate::geometry::*;
+use crate::lib8::interpolate::Fract8Ops;
+use crate::power::AsMilliwatts;
+use crate::task::Task;
+use crate::time::Periodically;
+use running_average::RealTimeRunningAverage;
+use core::fmt::Debug;
 
-pub trait Shader: Send {
-    fn draw(&self, surface_coords: VirtualCoordinates) -> RGB8;
+pub trait HardwarePixel: Send + Sync + Copy + AsMilliwatts + Default + From<Rgb<u8>> + Fract8Ops {}
+impl<T> HardwarePixel for T where T: Send + Sync + Copy + AsMilliwatts + Default + From<Rgb<u8>> + Fract8Ops {}
+
+pub trait PixelView {
+    type Pixel: HardwarePixel;
+    fn next(&mut self) -> Option<(Coordinates<Virtual>, &mut Self::Pixel)>;
 }
 
-pub trait Surface: Default + Clone {
-    fn with_shader<F: FnMut(&dyn Shader)>(&self, f: F);
+pub trait Sample {
+    type Pixel: HardwarePixel;
+
+    fn sample(&mut self, rect: &Rectangle<Virtual>) -> impl PixelView<Pixel = Self::Pixel>;
+}
+
+pub trait Shader: Send + Sync {
+    fn draw(&self, surface_coords: &VirtualCoordinates, frame: usize) -> Rgb<u8>;
+}
+
+pub trait Surfaces: Send + Sync {
+    type Surface: Surface;
+    type Error: Debug;
+    fn new_surface(&mut self, area: &Rectangle<Virtual>) -> Result<Self::Surface, Self::Error>;
+    fn render_to<S: Sample>(&self, output: &mut S, frame: usize);
+}
+
+pub trait Surface: Send + Sync {
     fn set_shader(&mut self, shader: Box<dyn Shader>);
     fn clear_shader(&mut self);
+
+    fn set_rect(&mut self, rect: &Rectangle<Virtual>);
     fn set_opacity(&mut self, opacity: u8);
 }
 
-pub trait Surfaces<T: Surface> {
-    fn new_surface(&mut self) -> Result<T, io::Error>;
+pub trait Output: Sample + Send {
+    fn blank(&mut self);
+    fn commit(&mut self);
 }
 
-pub trait Display<T: Surface>: Surfaces<T> {
-    fn start_frame(&mut self) {}
-    fn end_frame(&mut self) {}
-    fn render_frame(&mut self);
+#[derive(Debug)]
+pub struct Renderer<T: Output, S: Surfaces> {
+    output: T,
+    surfaces: S,
+    fps: RealTimeRunningAverage<u32>,
+    fps_display: Periodically,
+    frame: usize
 }
 
-pub struct ShaderBinding {
-    shader: Option<Box<dyn Shader>>,
-    opacity: u8,
-}
-
-#[derive(Clone)]
-pub struct BoundSurface<T> {
-    pub binding: T
-}
-
-pub type SharedSurface = BoundSurface<Arc<Mutex<ShaderBinding>>>;
-pub type SimpleSurface = BoundSurface<Rc<RefCell<ShaderBinding>>>;
-
-impl Default for BoundSurface<Arc<Mutex<ShaderBinding>>> {
-    fn default() -> Self {
+impl<T: Output, S: Surfaces> Renderer<T, S> {
+    pub fn new(output: T, surfaces: S) -> Self {
         Self {
-            binding: Arc::new(Mutex::new(ShaderBinding {
-                shader: None,
-                opacity: 255,
-            })),
+            output,
+            surfaces: surfaces,
+            fps: RealTimeRunningAverage::default(),
+            fps_display: Periodically::new_every_n_seconds(5),
+            frame: 0
         }
     }
 }
 
-impl Default for BoundSurface<Rc<RefCell<ShaderBinding>>>{
-    fn default() -> Self {
-        Self {
-            binding: Rc::new(RefCell::new(ShaderBinding {
-                shader: None,
-                opacity: 255,
-            })),
-        }
-    }
-}
-
-impl Surface for BoundSurface<Rc<RefCell<ShaderBinding>>> {
-    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut f: F) {
-        if let Some(ref shader) = self.binding.borrow().shader {
-            f(shader.as_ref());
-        }
-    }
-
-    fn set_shader(&mut self, shader: Box<dyn Shader>) {
-        self.binding.borrow_mut().shader = Some(shader);
-    }
-
-    fn clear_shader(&mut self) {
-        self.binding.borrow_mut().shader = None;
-    }
-
-    fn set_opacity(&mut self, opacity: u8) {
-        self.binding.borrow_mut().opacity = opacity;
-    }
-}
-
-impl Surface for BoundSurface<Arc<Mutex<ShaderBinding>>> {
-    fn with_shader<F: FnMut(&dyn Shader)>(&self, mut f: F) {
-        if let Some(ref shader) = self.binding.lock().unwrap().shader {
-            f(shader.as_ref());
-        }
-    }
-
-    fn set_shader(&mut self, shader: Box<dyn Shader>) {
-        self.binding.lock().unwrap().shader = Some(shader);
-    }
-
-    fn clear_shader(&mut self) {
-        self.binding.lock().unwrap().shader = None;
-    }
-
-    fn set_opacity(&mut self, opacity: u8) {
-        self.binding.lock().unwrap().opacity = opacity;
-    }
-}
-
-pub struct SurfacePool<S: Surface + Default> {
-    surfaces: Vec<S>
-}
-
-impl<S: Surface + Default> SurfacePool<S> {
-    pub const fn new() -> Self {
-        Self {
-            surfaces: Vec::new()
-        }
-    }
-
-    pub fn iter(&self) -> std::slice::Iter<S> {
-        self.surfaces.iter()
-    }
-}
-
-impl<S: Surface + Default + Clone> Surfaces<S> for SurfacePool<S> {
-    fn new_surface(&mut self) -> Result<S, io::Error> {
-        let surface = S::default();
-        self.surfaces.push(surface.clone());
-        return Ok(surface);
+impl<T: Output, S: Surfaces> Task for Renderer<T, S> {
+    fn name(&self) -> &'static str { "Renderer" }
+
+    fn tick(&mut self) {
+        self.output.blank();
+
+        self.surfaces.render_to(&mut self.output, self.frame);
+
+        self.output.commit();
+
+        self.fps.insert(1);
+        self.frame += 1;
+        self.fps_display.run(|| {
+            log::info!("FPS: {}", self.fps.measurement());
+        });
     }
 }

src/smart_leds_lib.rs

@@ -1,91 +0,0 @@
-use smart_leds_trait::SmartLedsWrite;
-use running_average::RealTimeRunningAverage;
-
-use crate::render::{Surface, SurfacePool, Display, Surfaces};
-use crate::task::Task;
-use crate::power;
-use crate::time::Periodically;
-use crate::lib8::RGB8;
-use crate::geometry::*;
-use crate::power::AsMilliwatts;
-
-use smart_leds::brightness;
-
-use std::io;
-
-use rgb::Rgb;
-
-pub struct SmartLedDisplay<T: SmartLedsWrite<Color = Rgb<u8>>, S: Surface> {
-    surfaces : SurfacePool<S>,
-    target: T,
-    fps: RealTimeRunningAverage<u32>,
-    frame: u32,
-    fps_display: Periodically,
-    pixbuf: [T::Color; 255],
-    total_mw: u32,
-    max_mw: u32
-}
-
-impl<T: SmartLedsWrite<Color = Rgb<u8>>, S: Surface> SmartLedDisplay<T, S> {
-    pub fn new(target: T, max_mw: u32) -> Self {
-        SmartLedDisplay {
-            surfaces: SurfacePool::new(),
-            target: target,
-            max_mw: max_mw,
-            total_mw: 0,
-            fps: RealTimeRunningAverage::default(),
-            frame: 0,
-            fps_display: Periodically::new_every_n_seconds(5),
-            pixbuf: [Rgb::new(0, 0, 0); 255]
-        }
-    }
-}
-
-impl<T: SmartLedsWrite<Color = Rgb<u8>>, S: Surface> Task for SmartLedDisplay<T, S> {
-    fn name(&self) -> &'static str { "Renderer" }
-
-    fn tick(&mut self) {
-        self.start_frame();
-        self.render_frame();
-        self.end_frame();
-    }
-}
-
-impl<T, S> Surfaces<S> for SmartLedDisplay<T, S>
-where
-T: SmartLedsWrite<Color = Rgb<u8>>,
-S: Surface {
-    fn new_surface(&mut self) -> Result<S, io::Error> {
-        self.surfaces.new_surface()
-    }
-}
-
-impl<T: SmartLedsWrite<Color = Rgb<u8>>, S: Surface> Display<S> for SmartLedDisplay<T, S> {
-    fn start_frame(&mut self) {
-        self.frame = self.frame.wrapping_add(1);
-        self.total_mw = 0;
-    }
-
-    fn end_frame(&mut self) {
-        self.fps.insert(1);
-        let b = power::brightness_for_mw(self.total_mw, 255, self.max_mw);
-        self.fps_display.run(|| {
-            log::info!("FPS: {} frame={} brightness={} mw={}", self.fps.measurement(), self.frame, b, self.total_mw);
-        });
-        self.target.write(brightness(self.pixbuf.iter().cloned(), b));
-    }
-
-    fn render_frame(&mut self) {
-        for x in 0..self.pixbuf.len() {
-            let virtCoords = VirtualCoordinates::new(x as u8, 0);
-            let mut pixel = RGB8::new(0, 0, 0);
-            for surface in self.surfaces.iter() {
-                surface.with_shader(|shader| {
-                    pixel = shader.draw(virtCoords.clone());
-                })
-            }
-            self.total_mw += pixel.as_milliwatts();
-            self.pixbuf[x] = Rgb::new(pixel.red, pixel.green, pixel.blue);
-        };
-    }
-}

src/task.rs

@@ -1,91 +1,28 @@
-use std::fmt;
+use core::fmt;
 
-pub trait Task {
+pub trait Task: Send {
     fn tick(&mut self) {}
     fn start(&mut self) {}
     fn stop(&mut self) {}
-    fn name(&self) -> &'static str;
-}
-
-trait ScheduledState: std::fmt::Debug {
-    fn start(self: Box<Self>) -> Box<dyn ScheduledState>;
-    fn stop(self: Box<Self>) -> Box<dyn ScheduledState>;
-    fn tick(self: Box<Self>, task: &mut dyn Task) -> Box<dyn ScheduledState>;
-}
-
-#[derive(Debug)]
-struct Starting {}
-impl ScheduledState for Starting {
-    fn start(self: Box<Self>) -> Box<dyn ScheduledState> {
-        self
-    }
-
-    fn stop(self: Box<Self>) -> Box<dyn ScheduledState> {
-        Box::new(Stopped {})
-    }
-
-    fn tick(self: Box<Self>, task: &mut dyn Task) -> Box<dyn ScheduledState> {
-        task.start();
-        Box::new(Running{})
+    fn name(&self) -> &'static str {
+        core::any::type_name::<Self>()
     }
 }
 
-#[derive(Debug)]
-struct Running {}
-impl ScheduledState for Running {
-    fn start(self: Box<Self>) -> Box<dyn ScheduledState> {
-        self
-    }
-
-    fn stop(self: Box<Self>) -> Box<dyn ScheduledState> {
-        Box::new(Stopping {})
-    }
-
-    fn tick(self: Box<Self>, task: &mut dyn Task) -> Box<dyn ScheduledState> {
-        task.tick();
-        self
-    }
-}
-
-#[derive(Debug)]
-struct Stopping {}
-impl ScheduledState for Stopping  {
-    fn start(self: Box<Self>) -> Box<dyn ScheduledState> {
-        Box::new(Running {})
-    }
-
-    fn stop(self: Box<Self>) -> Box<dyn ScheduledState> {
-        self
-    }
-
-    fn tick(self: Box<Self>, task: &mut dyn Task) -> Box<dyn ScheduledState> {
-        task.stop();
-        Box::new(Stopped {})
-    }
-}
-
-#[derive(Debug)]
-struct Stopped {}
-impl ScheduledState for Stopped  {
-    fn start(self: Box<Self>) -> Box<dyn ScheduledState> {
-        Box::new(Starting {})
-    }
-
-    fn stop(self: Box<Self>) -> Box<dyn ScheduledState> {
-        self
-    }
-
-    fn tick(self: Box<Self>, _task: &mut dyn Task) -> Box<dyn ScheduledState> {
-        self
-    }
+#[derive(Debug, Copy, Clone)]
+enum ScheduledState {
+    Stopped,
+    Start,
+    Running,
+    Stop
 }
 
 struct ScheduledTask {
-    state: Option<Box<dyn ScheduledState>>,
+    state: ScheduledState,
     task: Box<dyn Task>,
 }
 
-impl std::fmt::Debug for ScheduledTask {
+impl core::fmt::Debug for ScheduledTask {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ScheduledTask")
             .field("task", &self.task.name())
@@ -97,49 +34,78 @@ impl std::fmt::Debug for ScheduledTask {
 impl ScheduledTask {
     fn new(task: Box<dyn Task>) -> Self {
         ScheduledTask {
-            state: Some(Box::new(Starting{})),
+            state: ScheduledState::Start,
             task: task,
         }
     }
 
     fn start(&mut self) {
-        if let Some(s) = self.state.take() {
-            self.state = Some(s.start());
+        self.state = match self.state {
+            ScheduledState::Stopped => ScheduledState::Start,
+            ScheduledState::Stop => ScheduledState::Running,
+            _ => self.state
         }
     }
 
     fn stop(&mut self) {
-        if let Some(s) = self.state.take() {
-            self.state = Some(s.stop());
+        self.state = match self.state {
+            ScheduledState::Running => ScheduledState::Stop,
+            ScheduledState::Start => ScheduledState::Stopped,
+            _ => self.state
         }
     }
 
     fn tick(&mut self) {
-        if let Some(s) = self.state.take() {
-            self.state = Some(s.tick(self.task.as_mut()));
+        self.state = match self.state {
+            ScheduledState::Start => {
+                log::info!("Starting task {}", self.task.name());
+                self.task.start();
+                ScheduledState::Running
+            },
+            ScheduledState::Running => {
+                self.task.tick();
+                ScheduledState::Running
+            },
+            ScheduledState::Stop => {
+                log::info!("Stopping task {}", self.task.name());
+                self.task.stop();
+                ScheduledState::Stopped
+            },
+            ScheduledState::Stopped => ScheduledState::Stopped
         }
     }
 }
 
-pub struct Scheduler {
-    tasks: Vec<ScheduledTask>,
+#[derive(Debug)]
+pub struct FixedSizeScheduler<const TASK_COUNT: usize> {
+    tasks: [Option<ScheduledTask>; TASK_COUNT],
 }
 
-impl Scheduler {
-    pub fn new(tasks: Vec<Box<dyn Task>>) -> Self {
-        let mut scheduled = Vec::new();
+impl<const TASK_COUNT: usize> FixedSizeScheduler<TASK_COUNT> {
+    pub fn new(tasks: [Box<dyn Task>; TASK_COUNT]) -> Self {
+        let mut scheduled = [const { None }; TASK_COUNT];
+        let mut idx = 0;
         for task in tasks {
-            log::info!("Scheduling task {:?}", task.name());
-            scheduled.push(ScheduledTask::new(task));
+            scheduled[idx] = Some(ScheduledTask::new(task));
+            idx += 1;
         }
-        Scheduler {
+        FixedSizeScheduler {
             tasks: scheduled
         }
     }
+}
 
-    pub fn tick(&mut self) {
-        for task in &mut self.tasks {
-            task.tick();
+impl<const TASK_COUNT: usize> Scheduler for FixedSizeScheduler<TASK_COUNT> {
+    fn tick(&mut self) {
+        for slot in &mut self.tasks {
+            match slot {
+                Some(task) => task.tick(),
+                _ => ()
+            }
         }
     }
 }
+
+pub trait Scheduler {
+    fn tick(&mut self);
+}

src/time.rs

@@ -1,5 +1,7 @@
-use std::time::{Instant, Duration};
+use core::time::Duration;
+use std::time::Instant;
 
+#[derive(Debug, Clone, Copy)]
 pub struct Periodically {
     last_run: Instant,
     duration: Duration
@@ -22,9 +24,17 @@ impl Periodically {
     }
 
     pub fn run<F>(&mut self, f: F) where F: FnOnce() {
-        if self.last_run.elapsed() >= self.duration {
+        if self.tick() {
             f();
+        }
+    }
+
+    pub fn tick(&mut self) -> bool {
+        if self.last_run.elapsed() >= self.duration {
             self.last_run = Instant::now();
+            true
+        } else {
+            false
         }
     }
 }