platform: move platform lib bits into platform module

src/platform/embedded_graphics_lib.rs

@@ -0,0 +1,148 @@
+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::*;
+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,
+    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();
+    }
+}
+
+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 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/mod.rs

@@ -0,0 +1,12 @@
+#[cfg(feature="embedded-graphics")]
+pub mod embedded_graphics_lib;
+
+#[cfg(feature="smart-leds")]
+pub mod smart_leds_lib;
+
+use crate::render::{Surface, Display};
+use crate::task::Task;
+
+pub trait DisplayInit {
+    fn new_display<S: Surface>() -> impl Display<S> + Task;
+}

src/platform/smart_leds_lib.rs

@@ -0,0 +1,160 @@
+use smart_leds_trait::SmartLedsWrite;
+use running_average::RealTimeRunningAverage;
+
+use crate::render::{Surface, SurfacePool, Display, Surfaces};
+use crate::task::Task;
+use crate::power::{brightness_for_mw, AsMilliwatts};
+use crate::time::Periodically;
+use crate::geometry::*;
+
+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 = 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);
+        });
+        let _ = self.target.write(brightness(self.pixbuf.iter().cloned(), b));
+    }
+
+    fn render_frame(&mut self) {
+        for x in 0..self.pixbuf.len() {
+            let virt_coords = VirtualCoordinates::new(x as u8, 0);
+            let mut pixel = Rgb::new(0, 0, 0);
+            for surface in self.surfaces.iter() {
+                surface.with_shader(|shader| {
+                    pixel = shader.draw(virt_coords.clone());
+                })
+            }
+            self.total_mw += pixel.as_milliwatts();
+            self.pixbuf[x] = Rgb::new(pixel.r, pixel.g, pixel.b);
+        };
+    }
+}
+
+#[cfg(feature="rmt")]
+pub mod rmt {
+    use esp_idf_svc::hal::prelude::Peripherals;
+    use ws2812_esp32_rmt_driver::lib_smart_leds::Ws2812Esp32Rmt;
+
+    use crate::render::{Display, Surface};
+    use crate::task::Task;
+    use crate::platform::smart_leds_lib::SmartLedDisplay;
+
+    use crate::platform::DisplayInit;
+    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);
+        }
+    }
+
+}
+
+#[cfg(feature="spi")]
+pub mod spi {
+    use ws2812_spi::Ws2812;
+
+    use crate::render::{Display, Surface};
+    use crate::task::Task;
+    use crate::platform::smart_leds_lib::SmartLedDisplay;
+
+    use esp_idf_svc::hal::{
+        prelude::*,
+        gpio::AnyIOPin,
+        spi::{
+            config::{Config, DriverConfig},
+            Dma,
+            SpiBusDriver,
+            SpiDriver,
+        }
+    };
+
+    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)
+        }
+    }
+}