platform: smart_leds: simplify trait hierarchy and push pixel type conversion even closer towards the hardware
This commit is contained in:
parent
a76d040ff6
commit
04f5575ba6
@ -19,7 +19,7 @@ use crate::platform::embedded_graphics_lib::PonderjarTarget as DisplayType;
|
||||
|
||||
#[cfg(feature="smart-leds")]
|
||||
#[cfg(feature="rmt")]
|
||||
use ws2812_esp32_rmt_driver::lib_smart_leds::Ws2812Esp32Rmt as DisplayType;
|
||||
use crate::platform::smart_leds_lib::rmt::FastWs2812Esp32Rmt as DisplayType;
|
||||
|
||||
#[cfg(feature="smart-leds")]
|
||||
#[cfg(feature="spi")]
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
use smart_leds_trait::SmartLedsWrite;
|
||||
|
||||
use crate::lib8::Rgb8Blend;
|
||||
use crate::lib8::interpolate::Fract8Ops;
|
||||
use crate::render::{Framed, Surface, Display, Surfaces};
|
||||
use crate::buffers::SurfacePool;
|
||||
use crate::power::{brightness_for_mw, AsMilliwatts};
|
||||
@ -8,19 +9,18 @@ use crate::geometry::*;
|
||||
use crate::mappings::*;
|
||||
use std::fmt::{Debug, Formatter};
|
||||
|
||||
use smart_leds::brightness;
|
||||
|
||||
use std::io;
|
||||
|
||||
use rgb::Rgb;
|
||||
use std::ops::IndexMut;
|
||||
|
||||
pub trait HardwarePixel: Rgb8Blend + Clone + Copy + AsMilliwatts + Default + From<Rgb<u8>> {}
|
||||
impl<T> HardwarePixel for T where T: Rgb8Blend + Clone + Copy + AsMilliwatts + Default + From<Rgb<u8>> {}
|
||||
pub trait HardwarePixel: Send + Sync + Rgb8Blend + Copy + AsMilliwatts + Default + From<Rgb<u8>> + Fract8Ops {}
|
||||
impl<T> HardwarePixel for T where T: Send + Sync + Rgb8Blend + Copy + AsMilliwatts + Default + From<Rgb<u8>> + Fract8Ops {}
|
||||
|
||||
pub trait Pixbuf<T: HardwarePixel>: AsMilliwatts + IndexMut<usize, Output=T> {
|
||||
fn new() -> Self;
|
||||
fn blank(&mut self);
|
||||
fn iter_with_brightness(&self, brightness: u8) -> impl Iterator<Item = T> + Send;
|
||||
}
|
||||
|
||||
impl<T: HardwarePixel, const PIXEL_NUM: usize> Pixbuf<T> for [T; PIXEL_NUM] {
|
||||
@ -31,22 +31,22 @@ impl<T: HardwarePixel, const PIXEL_NUM: usize> Pixbuf<T> for [T; PIXEL_NUM] {
|
||||
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)})
|
||||
}
|
||||
}
|
||||
|
||||
pub struct SmartLedDisplay<T: SmartLedsWrite, S: Surface, const PIXEL_NUM: usize> where
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color> {
|
||||
struct SmartLedDisplay<T: FastWrite, S: Surface, P: Pixbuf<T::Color>> {
|
||||
surfaces : Option<SurfacePool<S>>,
|
||||
pixmap: StrideMapping,
|
||||
target: T,
|
||||
pixbuf: [T::Color; PIXEL_NUM],
|
||||
pixbuf: P,
|
||||
max_mw: u32,
|
||||
frame: usize
|
||||
}
|
||||
|
||||
impl<T: SmartLedsWrite, S: Surface, const PIXEL_NUM: usize> Debug for SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color> {
|
||||
impl<T: FastWrite, S: Surface, P: Pixbuf<T::Color>> Debug for SmartLedDisplay<T, S, P> {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
|
||||
f.debug_struct("SmartLedDisplay")
|
||||
.field("total_mw", &self.pixbuf.as_milliwatts())
|
||||
@ -55,36 +55,32 @@ T::Color: HardwarePixel,
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: SmartLedsWrite, S: Surface, const PIXEL_NUM: usize> SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color> {
|
||||
pub fn new(target: T, max_mw: u32) -> Self {
|
||||
impl<T: FastWrite, S: Surface, P: Pixbuf<T::Color>> SmartLedDisplay<T, S, P> {
|
||||
fn new(target: T, max_mw: u32, pixmap: StrideMapping, pixbuf: P) -> Self {
|
||||
SmartLedDisplay {
|
||||
pixbuf: <[T::Color; PIXEL_NUM]>::new(),
|
||||
pixbuf,
|
||||
surfaces: Some(SurfacePool::new()),
|
||||
target,
|
||||
max_mw,
|
||||
pixmap: StrideMapping::new(),
|
||||
pixmap,
|
||||
frame: 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, S, const PIXEL_NUM: usize> AsMilliwatts for SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T: SmartLedsWrite,
|
||||
impl<T, S, P> AsMilliwatts for SmartLedDisplay<T, S, P> where
|
||||
T: FastWrite,
|
||||
S: Surface,
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color> {
|
||||
P: Pixbuf<T::Color> {
|
||||
fn as_milliwatts(&self) -> u32 {
|
||||
self.pixbuf.as_milliwatts()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, S, const PIXEL_NUM: usize> Surfaces<S> for SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T: SmartLedsWrite,
|
||||
impl<T, S, P> Surfaces<S> for SmartLedDisplay<T, S, P> where
|
||||
T: FastWrite,
|
||||
S: Surface,
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color> {
|
||||
P: Pixbuf<T::Color> {
|
||||
fn new_surface(&mut self, area: &Rectangle<u8, Virtual>) -> Result<S, io::Error> {
|
||||
if let Some(ref mut s) = self.surfaces {
|
||||
s.new_surface(area)
|
||||
@ -94,38 +90,43 @@ T::Color: HardwarePixel,
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, S, const PIXEL_NUM: usize> Display<S> for SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T: SmartLedsWrite,
|
||||
impl<T, S, P> Display<S> for SmartLedDisplay<T, S, P> where
|
||||
T: FastWrite,
|
||||
S: Surface,
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color>,
|
||||
Rgb<u8>: From<T::Color>
|
||||
{
|
||||
P: Pixbuf<T::Color> {
|
||||
fn render_frame(&mut self) {
|
||||
let surfaces = self.surfaces.take().unwrap();
|
||||
for surface in surfaces.iter() {
|
||||
let rect = surface.rect().clone();
|
||||
let mut sel = self.pixmap.select(&rect);
|
||||
surface.with_shader(|shader| {
|
||||
while let Some((virt_coords, phys_coords)) = sel.next() {
|
||||
let idx = phys_coords.x as usize;
|
||||
if idx >= PIXEL_NUM {
|
||||
continue;
|
||||
let opacity = surface.opacity();
|
||||
if opacity > 0 {
|
||||
surface.with_shader(|shader| {
|
||||
while let Some((virt_coords, phys_coords)) = sel.next() {
|
||||
let idx = self.pixmap.to_idx(&phys_coords);
|
||||
self.pixbuf[idx] = self.pixbuf[idx].blend8(shader.draw(&virt_coords, self.frame).into(), opacity);
|
||||
}
|
||||
self.pixbuf[idx] = self.pixbuf[idx].saturating_add(shader.draw(&virt_coords, self.frame));
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
self.surfaces = Some(surfaces);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, S, const PIXEL_NUM: usize> Framed for SmartLedDisplay<T, S, PIXEL_NUM> where
|
||||
T: SmartLedsWrite,
|
||||
trait FastWrite {
|
||||
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;
|
||||
}
|
||||
|
||||
impl<T, S, P> Framed for SmartLedDisplay<T, S, P> where
|
||||
T: FastWrite,
|
||||
S: Surface,
|
||||
T::Color: HardwarePixel,
|
||||
[T::Color; PIXEL_NUM]: Pixbuf<T::Color>,
|
||||
Rgb<u8>: From<T::Color> {
|
||||
P: Pixbuf<T::Color> {
|
||||
|
||||
fn start_frame(&mut self) {
|
||||
self.pixbuf.blank();
|
||||
@ -133,8 +134,8 @@ Rgb<u8>: From<T::Color> {
|
||||
|
||||
fn end_frame(&mut self) {
|
||||
let b = brightness_for_mw(self.pixbuf.as_milliwatts(), 255, self.max_mw);
|
||||
if let Err(_) = self.target.write(brightness(self.pixbuf.iter().cloned().map(|x| { x.into() }), b)) {
|
||||
panic!("Could not write frame");
|
||||
if let Err(_) = self.target.fast_write(self.pixbuf.iter_with_brightness(b)) {
|
||||
panic!("Could not write frame!");
|
||||
}
|
||||
self.frame += 1;
|
||||
}
|
||||
@ -143,43 +144,90 @@ Rgb<u8>: From<T::Color> {
|
||||
#[cfg(feature="rmt")]
|
||||
pub mod rmt {
|
||||
use esp_idf_svc::hal::prelude::Peripherals;
|
||||
use ws2812_esp32_rmt_driver::lib_smart_leds::LedPixelEsp32Rmt;
|
||||
use ws2812_esp32_rmt_driver::driver::color::LedPixelColor;
|
||||
|
||||
use crate::render::{Display, Surface};
|
||||
use crate::platform::smart_leds_lib::{Pixbuf, SmartLedDisplay, HardwarePixel};
|
||||
use crate::platform::DisplayInit;
|
||||
use ws2812_esp32_rmt_driver::driver::color::{LedPixelColor, LedPixelColorGrb24};
|
||||
use smart_leds::SmartLedsWrite;
|
||||
use rgb::Rgb;
|
||||
use ws2812_esp32_rmt_driver::LedPixelEsp32Rmt;
|
||||
|
||||
impl<CSmart, CDev> DisplayInit for LedPixelEsp32Rmt<'_, CSmart, CDev> where
|
||||
CSmart: HardwarePixel,
|
||||
[CSmart; 310]: Pixbuf<CSmart>,
|
||||
CDev: LedPixelColor + From<CSmart>,
|
||||
Rgb<u8>: From<CSmart>
|
||||
{
|
||||
use crate::mappings::StrideMapping;
|
||||
use crate::render::{Display, Surface};
|
||||
use crate::platform::DisplayInit;
|
||||
|
||||
use super::{Pixbuf, FastWrite, SmartLedDisplay};
|
||||
|
||||
use crate::lib8::Rgb8Blend;
|
||||
use crate::lib8::interpolate::{Fract8, Fract8Ops};
|
||||
use crate::power::AsMilliwatts;
|
||||
|
||||
pub type FastWs2812Esp32Rmt<'a> = LedPixelEsp32Rmt<'a, Rgb<u8>, LedPixelColorGrb24>;
|
||||
|
||||
impl Fract8Ops for LedPixelColorGrb24 {
|
||||
fn blend8(self, other: Self, scale: Fract8) -> Self {
|
||||
self
|
||||
}
|
||||
|
||||
fn scale8(self, scale: Fract8) -> Self {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsMilliwatts for LedPixelColorGrb24 {
|
||||
fn as_milliwatts(&self) -> u32 {
|
||||
Rgb::new(self.r(), self.g(), self.b()).as_milliwatts()
|
||||
}
|
||||
}
|
||||
|
||||
impl Rgb8Blend for LedPixelColorGrb24 {
|
||||
fn saturating_add<T: Into<Self>>(self, b: T) -> Self where Self: Sized {
|
||||
let s = b.into();
|
||||
LedPixelColorGrb24::new_with_rgb(s.r(), s.g(), s.b())
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
impl DisplayInit for FastWs2812Esp32Rmt<'_> {
|
||||
fn new_display<S: Surface>() -> impl Display<S> {
|
||||
let peripherals = Peripherals::take().unwrap();
|
||||
let led_pin = peripherals.pins.gpio14;
|
||||
//let led_pin = peripherals.pins.gpio5;
|
||||
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 pixbuf: [Rgb<u8>; 310] = Pixbuf::new();
|
||||
let pixbuf: [<Self as FastWrite>::Color; 310] = Pixbuf::new();
|
||||
let pixmap = StrideMapping::new_jar();
|
||||
|
||||
assert!(pixmap.pixel_count <= pixbuf.len(), "map needs {} pixels, I only have PIXEL_NUM={}", pixmap.pixel_count, pixbuf.len());
|
||||
|
||||
let target = Self::new(channel, led_pin).unwrap();
|
||||
return SmartLedDisplay::<Self, S, 310>::new(target, MAX_POWER_MW);
|
||||
return SmartLedDisplay::new(target, MAX_POWER_MW, pixmap, pixbuf);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature="spi")]
|
||||
pub mod spi {
|
||||
use ws2812_spi::Ws2812;
|
||||
use smart_leds::SmartLedsWrite;
|
||||
use ws2812_spi::prerendered::Ws2812;
|
||||
|
||||
use crate::render::{Display, Surface};
|
||||
use crate::task::Task;
|
||||
use crate::platform::smart_leds_lib::SmartLedDisplay;
|
||||
use crate::DisplayInit;
|
||||
use super::FastWrite;
|
||||
|
||||
use esp_idf_svc::hal::{
|
||||
prelude::*,
|
||||
@ -192,27 +240,49 @@ pub mod spi {
|
||||
}
|
||||
};
|
||||
|
||||
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> + Task {
|
||||
fn new_display<S: Surface>() -> impl Display<S> {
|
||||
let peripherals = Peripherals::take().unwrap();
|
||||
|
||||
let driver = SpiDriver::new_without_sclk(
|
||||
peripherals.spi2,
|
||||
peripherals.pins.gpio14,
|
||||
peripherals.pins.gpio5,
|
||||
Option::<AnyIOPin>::None,
|
||||
&DriverConfig::new().dma(Dma::Auto(512))
|
||||
&DriverConfig::new().dma(Dma::Auto(4092))
|
||||
).unwrap();
|
||||
|
||||
let cfg = Config::new().baudrate(3_200.kHz().into());
|
||||
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;
|
||||
let target = Ws2812::new(spi);
|
||||
return SmartLedDisplay::new(target, MAX_POWER_MW)
|
||||
unsafe {
|
||||
let target = Ws2812::new(spi, &mut STATIC_BUFFER);
|
||||
return SmartLedDisplay::<Ws2812<SpiBusDriver<'_, SpiDriver<'_>>>, S, 310>::new(target, MAX_POWER_MW);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user