tdfischer/renderbug-bike
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

oled: split out the ssd1306 driver into its own module, and reimplement the oled design with separate rendering and drawing tasks

Browse Source
This commit is contained in:
Victoria Fischer
2025-10-25 17:51:03 +02:00
parent db912e0085
commit 27e92edef0
9 changed files with 412 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

268
src/tasks/oled.rs
View File

@@ -1,19 +1,23 @@
use core::{cell::RefCell, f32::consts::PI};
use core::{cell::{Cell, RefCell}, cmp::min, f32::consts::PI, fmt::Binary, ops::DerefMut};
use alloc::format;
use embassy_sync::pubsub::DynSubscriber;
use embassy_time::Timer;
use alloc::{format, sync::Arc};
use display_interface::DisplayError;
use embassy_executor::{raw, Spawner};
use embassy_sync::{blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex}, mutex::Mutex, pubsub::DynSubscriber};
use embassy_time::{Delay, Duration, Instant, Timer};
use embedded_graphics::{image::Image, mono_font::{ascii::{FONT_6X10, FONT_10X20, FONT_9X18_BOLD}, MonoTextStyleBuilder}, pixelcolor::BinaryColor, prelude::*, primitives::{Line, PrimitiveStyleBuilder, Rectangle, StyledDrawable}, text::{Alignment, Baseline, Text}};
use esp_hal::{i2c::master::I2c, Async, gpio::Output};
use figments::{liber8tion::{interpolate::{ease_in_out_quad, scale8}, trig::{cos8, sin8}}, prelude::Fract8Ops};
use nalgebra::Vector2;
use figments::{liber8tion::{interpolate::{ease_in_out_quad, scale8, Fract8}, trig::{cos8, sin8}}, mappings::{embedded_graphics::{EmbeddedGraphicsSampler, Matrix2DSpace}, linear::LinearSpace}, pixels::{PixelBlend, PixelSink}, prelude::{CoordinateSpace, Coordinates, Fract8Ops}, render::{RenderSource, Sample}, surface::{BufferedSurface, BufferedSurfacePool, Surface, SurfaceBuilder, Surfaces}};
use figments_render::output::{Brightness, NullControls, OutputAsync};
use futures::{join, FutureExt};
use nalgebra::{Matrix, Vector2};
use ssd1306::{mode::{BufferedGraphicsModeAsync, DisplayConfigAsync}, prelude::{DisplayRotation, I2CInterface}, size::DisplaySize128x64, I2CDisplayInterface, Ssd1306Async};
use log::*;
use embedded_graphics::mono_font::MonoTextStyle;
use embedded_graphics::primitives::PrimitiveStyle;
use nalgebra::ComplexField;
use crate::{backoff::Backoff, ego::engine::MotionState, events::{Notification, Prediction, Scene, SensorSource, Telemetry}, tasks::ui};
use crate::{animation::{AnimatedSurface, Animation}, backoff::Backoff, ego::engine::MotionState, events::{Notification, Prediction, Scene, SensorSource, Telemetry}, graphics::ssd1306::{SsdControls, SsdOutput, SsdPixel}, tasks::ui};
mod images {
use embedded_graphics::{
@@ -23,7 +27,7 @@ mod images {
include!("../../target/images.rs");
}
#[derive(Default)]
#[derive(Default, Debug)]
struct OledUI {
scene: Scene,
motion: MotionState,
@@ -36,7 +40,13 @@ struct OledUI {
sleep: bool,
}
struct UiPainter<'a>(&'a mut Ssd1306Async<I2CInterface<I2c<'static, Async>>, DisplaySize128x64, BufferedGraphicsModeAsync<DisplaySize128x64>>);
#[derive(Default, Debug)]
struct OledUniforms {
ui: OledUI,
frame: usize,
current_screen: Screen,
next_screen: Screen
}
#[derive(Debug, Default, Clone, Copy)]
enum Screen {
@@ -48,132 +58,108 @@ enum Screen {
Waking
}
impl UiPainter<'_> {
pub async fn screen_transition(&mut self, from: Screen, to: Screen, state: &OledUI) {
warn!("Transitioning screens from {from:?} to {to:?}");
for pos in 0..16 {
self.blank();
// Draw the screen, then paint the swipe across it from left to right
self.draw_screen(from, 0, state);
Rectangle::new(Point::zero(), Size { width: figments::liber8tion::interpolate::ease_in_out_quad(pos*8) as u32, height: 64}).draw_styled(&DRAW_STYLE, self.0).unwrap();
self.commit().await;
}
for pos in 0..16 {
self.blank();
// Paint the next screen, then cover the right half with the swipe
self.draw_screen(to, 0, state);
let pos = figments::liber8tion::interpolate::ease_in_out_quad(pos*8) as u32;
Rectangle::new(Point::new(pos as i32, 0), Size { width: 128 - pos, height: 64}).draw_styled(&DRAW_STYLE, self.0).unwrap();
self.commit().await;
}
// Finally draw the untouched screen
self.blank();
self.draw_screen(to, 0, state);
self.commit().await;
}
pub fn draw_screen(&mut self, screen: Screen, frame: usize, ui_state: &OledUI) {
match screen {
impl Screen {
pub fn draw_screen<'a, T>(&self, sampler: &mut EmbeddedGraphicsSampler<'a, T>, state: &OledUniforms) where T: Sample<'a, Matrix2DSpace>, T::Output: PixelSink<BinaryColor> {
match self {
Screen::Blank => (),
Screen::Bootsplash => {
Image::new(&images::BOOT_LOGO, Point::zero()).draw(self.0).unwrap();
Image::new(&images::BOOT_LOGO, Point::zero()).draw(sampler).unwrap();
const SPARKLE_COUNT: i32 = 8;
for n in 0..SPARKLE_COUNT {
let sparkle_center = Point::new(128u8.scale8(cos8(frame.wrapping_mul(n as usize))) as i32, 64u8.scale8(sin8(frame.wrapping_mul(n as usize) as u8)) as i32);
let offset = (frame / 2 % 32) as i32 - 16;
let rotation = PI * 2.0 * (sin8(frame) as f32 / 255.0);
let sparkle_center = Point::new(128u8.scale8(cos8(state.frame.wrapping_mul(n as usize))) as i32, 64u8.scale8(sin8(state.frame.wrapping_mul(n as usize) as u8)) as i32);
let offset = (state.frame / 2 % 32) as i32 - 16;
let rotation = PI * 2.0 * (sin8(state.frame) as f32 / 255.0);
let normal = Point::new((rotation.cos() * offset as f32) as i32, (rotation.sin() * offset as f32) as i32);
let cross_normal = Point::new((rotation.sin() * offset as f32) as i32, (rotation.cos() * offset as f32) as i32);
// Draw horizontal
Line::new(sparkle_center - normal, sparkle_center + normal)
.draw_styled(&SPARKLE_STYLE, self.0).unwrap();
.draw_styled(&SPARKLE_STYLE, sampler).unwrap();
// Draw vertical
Line::new(sparkle_center - cross_normal, sparkle_center + cross_normal)
.draw_styled(&SPARKLE_STYLE, self.0).unwrap();
.draw_styled(&SPARKLE_STYLE, sampler).unwrap();
}
},
Screen::Home => {
// Status bar
// Sensor indicators
let gps_img = if ui_state.gps_online {
let gps_img = if state.ui.gps_online {
&images::GPS_ON
} else {
&images::GPS_OFF
};
let imu_img = if ui_state.imu_online {
let imu_img = if state.ui.imu_online {
&images::IMU_ON
} else {
&images::IMU_OFF
};
Image::new(gps_img, Point::zero()).draw(self.0).unwrap();
Image::new(imu_img, Point::new((gps_img.size().width + 2) as i32, 0)).draw(self.0).unwrap();
Image::new(gps_img, Point::zero()).draw(sampler).unwrap();
Image::new(imu_img, Point::new((gps_img.size().width + 2) as i32, 0)).draw(sampler).unwrap();
#[cfg(feature="demo")]
Text::with_alignment("Demo", Point::new(128, 10), TEXT_STYLE, Alignment::Right)
.draw(self.0)
.draw(sampler)
.unwrap();
#[cfg(feature="simulation")]
Text::with_alignment("Sim", Point::new(128, 10), TEXT_STYLE, Alignment::Right)
.draw(self.0)
.draw(sampler)
.unwrap();
// Separates the status bar from the UI
Line::new(Point::new(0, 18), Point::new(128, 18)).draw_styled(&INACTIVE_STYLE, self.0).unwrap();
Line::new(Point::new(0, 18), Point::new(128, 18)).draw_styled(&INACTIVE_STYLE, sampler).unwrap();
// Speed display at the top
Text::with_alignment(&format!("{}", ui_state.velocity), Point::new(128 / 2, 12), SPEED_STYLE, Alignment::Center)
.draw(self.0)
Text::with_alignment(&format!("{}", state.ui.velocity), Point::new(128 / 2, 12), SPEED_STYLE, Alignment::Center)
.draw(sampler)
.unwrap();
// The main UI content
Image::new(&images::BIKE, Point::new((128 / 2 - images::BIKE.size().width / 2) as i32, 24)).draw(self.0).unwrap();
Image::new(&images::BIKE, Point::new((128 / 2 - images::BIKE.size().width / 2) as i32, 24)).draw(sampler).unwrap();
let headlight_img = if ui_state.headlight {
let headlight_img = if state.ui.headlight {
&images::HEADLIGHT_ON
} else {
&images::HEADLIGHT_OFF
};
let brakelight_img = if ui_state.brakelight {
let brakelight_img = if state.ui.brakelight {
&images::BRAKELIGHT_ON
} else {
&images::BRAKELIGHT_OFF
};
Image::new(headlight_img, Point::new(((128 / 2 - images::BIKE.size().width / 2) - 18) as i32, 28)).draw(self.0).unwrap();
Image::new(brakelight_img, Point::new(((128 / 2 + images::BIKE.size().width / 2) + 2) as i32, 28)).draw(self.0).unwrap();
Image::new(headlight_img, Point::new(((128 / 2 - images::BIKE.size().width / 2) - 18) as i32, 28)).draw(sampler).unwrap();
Image::new(brakelight_img, Point::new(((128 / 2 + images::BIKE.size().width / 2) + 2) as i32, 28)).draw(sampler).unwrap();
// TODO: Replace the state texts with cute animations or smth
// Current prediction from the motion engine
Text::with_alignment(&format!("{:?}", ui_state.motion), Point::new(128 / 2, 64 - 3), TEXT_STYLE, Alignment::Center)
.draw(self.0)
Text::with_alignment(&format!("{:?}", state.ui.motion), Point::new(128 / 2, 64 - 3), TEXT_STYLE, Alignment::Center)
.draw(sampler)
.unwrap();
// Current scene in the UI
Text::with_alignment(&format!("{:?}", ui_state.scene), Point::new(128 / 2, 64 - 13), TEXT_STYLE, Alignment::Center)
.draw(self.0)
Text::with_alignment(&format!("{:?}", state.ui.scene), Point::new(128 / 2, 64 - 13), TEXT_STYLE, Alignment::Center)
.draw(sampler)
.unwrap();
},
Screen::Sleeping => {
Text::with_alignment("so eepy Zzz...", Point::new(128 / 2, 64 / 2), LOGO_STYLE, Alignment::Center)
.draw(self.0)
.draw(sampler)
.unwrap();
},
Screen::Waking => {
Text::with_alignment("OwO hewwo again :D", Point::new(128 / 2, 64 / 2), LOGO_STYLE, Alignment::Center)
.draw(self.0)
.draw(sampler)
.unwrap();
}
}
}
}
pub fn blank(&mut self) {
self.0.clear_buffer();
}
pub async fn commit(&mut self) {
self.0.flush().await.expect("Could not commit frame");
impl RenderSource<OledUniforms, Matrix2DSpace, BinaryColor, SsdPixel> for Screen {
fn render_to<'a, Smp>(&'a self, output: &'a mut Smp, uniforms: &OledUniforms)
where
Smp: Sample<'a, Matrix2DSpace, Output = SsdPixel> {
let mut sampler = EmbeddedGraphicsSampler(output, embedded_graphics::primitives::Rectangle::new(Point::new(0, 0), Size::new(128, 64)));
self.draw_screen(&mut sampler, uniforms);
}
}
@@ -208,53 +194,75 @@ const INACTIVE_STYLE: PrimitiveStyle<BinaryColor> = PrimitiveStyleBuilder::new()
.build();
#[embassy_executor::task]
pub async fn oled_task(i2c: I2c<'static, Async>, mut reset_pin: Output<'static>, mut events: DynSubscriber<'static, Telemetry>) {
let interface = RefCell::new(Some(I2CDisplayInterface::new(i2c)));
let mut ui_state = OledUI::default();
async fn oled_render(mut output: SsdOutput, surfaces: BufferedSurfacePool<OledUniforms, Matrix2DSpace, BinaryColor>, uniforms: Arc<Mutex<NoopRawMutex, OledUniforms>>) {
Backoff::from_secs(1).forever().attempt::<_, (), DisplayError>(async || {
const FPS: u64 = 30;
const RENDER_BUDGET: Duration = Duration::from_millis(1000 / FPS);
// initialize the display
let mut display = Backoff::from_secs(3).forever().attempt(async || {
info!("Setting up OLED display");
Timer::after_millis(10).await;
reset_pin.set_high();
Timer::after_millis(10).await;
reset_pin.set_low();
Timer::after_millis(10).await;
reset_pin.set_high();
let mut display = Ssd1306Async::new(interface.replace(None).unwrap(), DisplaySize128x64, DisplayRotation::Rotate0)
.into_buffered_graphics_mode();
if let Err(e) = display.init().await {
warn!("Failed to set up OLED display: {e:?}");
interface.replace(Some(display.release()));
Err(())
} else {
Ok(display)
const ANIMATION_TPS: u64 = 30;
const ANIMATION_FRAME_TIME: Duration = Duration::from_millis(1000 / ANIMATION_TPS);
info!("Starting Oled renderer");
loop {
let start = Instant::now();
{
let mut locked = uniforms.lock().await;
output.clear(BinaryColor::Off).unwrap();
locked.frame = (Instant::now().as_millis() / ANIMATION_FRAME_TIME.as_millis()) as usize;
locked.current_screen.render_to(&mut output, &locked);
surfaces.render_to(&mut output, &locked);
}
output.commit_async().await?;
let frame_time = Instant::now() - start;
if frame_time < RENDER_BUDGET {
Timer::after(RENDER_BUDGET - frame_time).await;
} else {
//warn!("OLED Frame took too long to render! {}ms", frame_time.as_millis());
}
}
}).await.unwrap();
}
display.clear(BinaryColor::Off).unwrap();
display.flush().await.unwrap();
info!("Running boot splash animation");
let mut painter = UiPainter(&mut display);
painter.screen_transition(Screen::Blank, Screen::Bootsplash, &ui_state).await;
for i in 0..255 {
painter.blank();
painter.draw_screen(Screen::Bootsplash, i, &ui_state);
painter.commit().await;
async fn screen_transition(overlay: &mut BufferedSurface<OledUniforms, Matrix2DSpace, BinaryColor>, uniforms: &mut Arc<Mutex<NoopRawMutex, OledUniforms>>, next_screen: Screen) {
const FADE_IN: Animation = Animation::new().from(0).to(255).duration(Duration::from_millis(300));
const FADE_OUT: Animation = Animation::new().from(255).to(0).duration(Duration::from_millis(300));
info!("Fading in to screen {next_screen:?}");
FADE_IN.apply(overlay).await;
{
let mut locked = uniforms.lock().await;
locked.current_screen = next_screen;
}
painter.screen_transition(Screen::Bootsplash, Screen::Home, &ui_state).await;
FADE_OUT.apply(overlay).await;
}
#[embassy_executor::task]
async fn oled_ui(mut events: DynSubscriber<'static, Telemetry>, mut overlay: BufferedSurface<OledUniforms, Matrix2DSpace, BinaryColor>, mut uniforms: Arc<Mutex<NoopRawMutex, OledUniforms>>, mut controls: SsdControls) {
screen_transition(&mut overlay, &mut uniforms, Screen::Bootsplash).await;
Timer::after_secs(3).await;
screen_transition(&mut overlay, &mut uniforms, Screen::Home).await;
info!("OLED display is ready!");
loop {
// FIXME: Need to implement sleep handling to electrically turn the display on/off
if !ui_state.sleep {
painter.blank();
painter.draw_screen(Screen::Home, 0, &ui_state);
painter.commit().await;
}
let evt = events.next_message_pure().await;
//info!("Oled UI event: {evt:?}");
match evt {
Telemetry::Notification(Notification::Sleep) => {
screen_transition(&mut overlay, &mut uniforms, Screen::Sleeping).await;
Timer::after_secs(1).await;
screen_transition(&mut overlay, &mut uniforms, Screen::Blank).await;
controls.set_on(false);
//ui_state.sleep = true
},
Telemetry::Notification(Notification::WakeUp) => {
controls.set_on(true);
screen_transition(&mut overlay, &mut uniforms, Screen::Waking).await;
Timer::after_secs(1).await;
screen_transition(&mut overlay, &mut uniforms, Screen::Home).await;
//ui_state.sleep = false
},
_ => ()
}
let mut locked = uniforms.lock().await;
let ui_state = &mut locked.ui;
match evt {
Telemetry::Prediction(Prediction::Velocity(v)) => ui_state.velocity = v,
Telemetry::Prediction(Prediction::Location(loc)) => ui_state.location = loc,
@@ -266,19 +274,39 @@ pub async fn oled_task(i2c: I2c<'static, Async>, mut reset_pin: Output<'static>
Telemetry::Notification(Notification::SensorOnline(SensorSource::IMU)) => ui_state.imu_online = true,
Telemetry::Notification(Notification::SensorOffline(SensorSource::GPS)) => ui_state.gps_online = false,
Telemetry::Notification(Notification::SensorOnline(SensorSource::GPS)) => ui_state.gps_online = true,
Telemetry::Notification(Notification::Sleep) => {
painter.screen_transition(Screen::Home, Screen::Sleeping, &ui_state).await;
Timer::after_secs(1).await;
painter.screen_transition(Screen::Sleeping, Screen::Blank, &ui_state).await;
ui_state.sleep = true
},
Telemetry::Notification(Notification::WakeUp) => {
painter.screen_transition(Screen::Blank, Screen::Waking, &ui_state).await;
Timer::after_secs(1).await;
painter.screen_transition(Screen::Waking, Screen::Home, &ui_state).await;
ui_state.sleep = false
},
_ => ()
}
}
/*for (coords, pix) in output.sample(&figments::prelude::Rectangle::everything()) {
pix.set(&BinaryColor::Off);
}
Text::with_alignment("Foo", Point::new(128 / 2, 64 / 2), LOGO_STYLE, Alignment::Center).draw(&mut output).unwrap();
output.commit_async().await.unwrap();
Timer::after_secs(1).await;
let painter = UiPainter { current_screen: Screen::Bootsplash, next_screen: Screen::Bootsplash };
painter.render_to(&mut output, &OledUniforms { frame: 0, ui: ui_state });*/
}
#[embassy_executor::task]
pub async fn oled_task(i2c: I2c<'static, Async>, mut reset_pin: Output<'static>, events: DynSubscriber<'static, Telemetry>) {
let interface = I2CDisplayInterface::new(i2c);
let mut display = Ssd1306Async::new(interface, DisplaySize128x64, DisplayRotation::Rotate0);
display.reset(&mut reset_pin, &mut Delay).await.unwrap();
display.init_with_addr_mode(ssd1306::command::AddrMode::Horizontal).await.unwrap();
let output = SsdOutput::new(display);
let mut surfaces = BufferedSurfacePool::default();
let uniforms = Default::default();
let sfc = SurfaceBuilder::build(&mut surfaces).shader(|coords: &Coordinates<Matrix2DSpace>, uniforms: &OledUniforms| {
BinaryColor::On
}).opacity(0).finish().unwrap();
info!("Starting OLED display tasks!");
let spawner = Spawner::for_current_executor().await;
let ui_controls = output.controls().unwrap().clone();
spawner.must_spawn(oled_render(output, surfaces, Arc::clone(&uniforms)));
spawner.must_spawn(oled_ui(events, sfc, uniforms, ui_controls));
}