TRMNL dashboard for suspend intermission screen

ewired · ewired · commit f7974ac6ed5a · 2025-05-24T21:36:00.000-04:00
diff --git a/crates/core/src/context.rs b/crates/core/src/context.rs
@@ -1,3 +1,4 @@
+use crate::trmnl::TrmnlClient;
 use crate::view::keyboard::Layout;
 use std::path::Path;
 use std::collections::{BTreeMap, VecDeque};
@@ -29,6 +30,7 @@ const INPUT_HISTORY_SIZE: usize = 32;
 pub struct Context {
     pub fb: Box<dyn Framebuffer>,
     pub alarm_manager: Option<AlarmManager>,
+    pub trmnl_client: Option<TrmnlClient>,
     pub display: Display,
     pub settings: Settings,
     pub library: Library,
@@ -57,7 +59,9 @@ impl Context {
         let rng = Xoroshiro128Plus::seed_from_u64(Local::now().timestamp_subsec_nanos() as u64);
 
         let alarm_manager = rtc.map(AlarmManager::new);
-        Context { fb, alarm_manager, display: Display { dims, rotation },
+        let trmnl_client = settings.trmnl.is_some().then(|| TrmnlClient::new());
+
+        Context { fb, alarm_manager, trmnl_client, display: Display { dims, rotation },
                   library, settings, fonts, dictionaries: BTreeMap::new(),
                   keyboard_layouts: BTreeMap::new(), input_history: FxHashMap::default(),
                   battery, frontlight, lightsensor, notification_index: 0,
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
@@ -18,6 +18,7 @@ pub mod rtc;
 pub mod settings;
 pub mod font;
 pub mod context;
+pub mod trmnl;
 pub mod gesture;
 
 pub use rtc::{AlarmType, AlarmManager};
diff --git a/crates/core/src/rtc.rs b/crates/core/src/rtc.rs
@@ -99,6 +99,7 @@ impl Rtc {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AlarmType {
+    TrmnlRefresh,
     AutoPowerOff,
 }
 
diff --git a/crates/core/src/trmnl.rs b/crates/core/src/trmnl.rs
@@ -0,0 +1,160 @@
+use crate::settings;
+use anyhow::{anyhow, Result};
+use image::DynamicImage;
+use lazy_static::lazy_static;
+use serde::Deserialize;
+use std::{
+    path::PathBuf,
+    sync::{Arc, Mutex},
+    time::{Duration, Instant},
+};
+
+lazy_static! {
+    static ref GLOBAL_TRMNL_CLIENT: Arc<Mutex<Option<TrmnlClient>>> = Arc::new(Mutex::new(None));
+}
+
+#[derive(Debug, Deserialize)]
+struct SetupResponse {
+    status: u32,
+    api_key: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct DisplayResponse {
+    status: u32,
+    image_url: Option<String>,
+    refresh_rate: Option<u32>,
+}
+
+#[derive(Clone)]
+pub struct TrmnlClient {
+    refresh_rate: u32,
+    next_refresh_time: Option<Instant>,
+}
+
+impl TrmnlClient {
+    pub fn new() -> Self {
+        Self {
+            refresh_rate: 1800,
+            next_refresh_time: None,
+        }
+    }
+
+    pub fn refresh_rate(&self) -> u32 {
+        self.refresh_rate
+    }
+
+    fn set_next_refresh_time(&mut self) {
+        self.next_refresh_time =
+            Some(Instant::now() + Duration::from_secs(self.refresh_rate as u64));
+    }
+
+    fn setup(&mut self, config: &mut settings::Trmnl) -> Result<()> {
+        if config.access_key.is_some() {
+            return Ok(());
+        }
+
+        let setup_response: SetupResponse = ureq::get(&format!("{}/setup", config.api_base))
+            .header("ID", &config.mac_address)
+            .call()?
+            .body_mut()
+            .read_json()?;
+
+        if setup_response.status != 200 {
+            return Err(anyhow!(
+                "Setup failed, API provided status: {}",
+                setup_response.status
+            ));
+        }
+
+        let api_key = setup_response
+            .api_key
+            .ok_or_else(|| anyhow!("Missing API key in response"))?;
+
+        config.access_key = Some(api_key);
+
+        Ok(())
+    }
+
+    fn fetch_display(&mut self, config: &mut settings::Trmnl) -> Result<DynamicImage> {
+        self.setup(config)?;
+
+        let api_key = config
+            .access_key
+            .as_ref()
+            .ok_or_else(|| anyhow!("TRMNL API key not available"))?;
+
+        let display_response: DisplayResponse = ureq::get(&format!("{}/display", config.api_base))
+            .header("ID", &config.mac_address)
+            .header("Access-Token", api_key)
+            .header("Refresh-Rate", "1800")
+            .header("Battery-Voltage", "4.0")
+            .header("FW-Version", "Plato")
+            .header("RSSI", "-60")
+            .call()?
+            .body_mut()
+            .read_json()?;
+
+        if display_response.status != 0 {
+            return Err(anyhow!(
+                "Display fetch failed, API provided status: {}",
+                display_response.status
+            ));
+        }
+
+        let image_url = display_response
+            .image_url
+            .ok_or_else(|| anyhow!("Missing image URL in response"))?;
+
+        if let Some(rate) = display_response.refresh_rate {
+            self.refresh_rate = rate;
+        }
+
+        self.set_next_refresh_time();
+
+        let image_data = ureq::get(&image_url).call()?.body_mut().read_to_vec()?;
+
+        let image = image::load_from_memory(&image_data)?;
+
+        Ok(image)
+    }
+
+    pub fn save_current_display(
+        &mut self,
+        rotation: i8,
+        config: &mut settings::Trmnl,
+    ) -> Option<PathBuf> {
+        let mut image = match self.fetch_display(config) {
+            Ok(img) => img,
+            Err(e) => {
+                eprintln!("Failed to fetch TRMNL display: {:?}", e);
+                return None;
+            }
+        };
+
+        // Always rotate back to landscape upright
+        match rotation {
+            3 => image = image.rotate90(),
+            2 => image = image.rotate180(),
+            1 => image = image.rotate270(),
+            _ => {}
+        }
+
+        let temp_dir = std::env::temp_dir();
+        let path = temp_dir.join("trmnl_display.png");
+
+        match image.save(&path) {
+            Ok(_) => {
+                println!(
+                    "Saved TRMNL display to: {:?} with given rotation {}",
+                    path, rotation
+                );
+                Some(path)
+            }
+            Err(e) => {
+                eprintln!("Failed to save TRMNL display: {:?}", e);
+                None
+            }
+        }
+    }
+}
diff --git a/crates/core/src/view/intermission.rs b/crates/core/src/view/intermission.rs
@@ -52,6 +52,31 @@ impl Intermission {
             halt: kind == IntermKind::PowerOff,
         }
     }
+
+    pub fn trmnl_or_new(rect: Rectangle, kind: IntermKind, context: &mut Context) -> Intermission {
+        let trmnl_client = match context.trmnl_client.as_mut() {
+            Some(client) => client,
+            None => return Intermission::new(rect, kind, context),
+        };
+
+        let trmnl_config = match context.settings.trmnl.as_mut() {
+            Some(config) => config,
+            None => return Intermission::new(rect, kind, context),
+        };
+
+        let path = match trmnl_client.save_current_display(context.display.rotation, trmnl_config) {
+            Some(path) => path,
+            None => return Intermission::new(rect, kind, context),
+        };
+
+        Intermission { 
+            id: ID_FEEDER.next(),
+            rect,
+            children: Vec::new(),
+            message: Message::Image(path),
+            halt: kind == IntermKind::PowerOff,
+        }
+    }
 }
 
 impl View for Intermission {
diff --git a/crates/emulator/src/main.rs b/crates/emulator/src/main.rs
@@ -376,7 +376,7 @@ fn main() -> Result<(), Error> {
                                             Scancode::C => IntermKind::Share,
                                             _ => unreachable!(),
                                         };
-                                        let interm = Intermission::new(context.fb.rect(), kind, &context);
+                                        let interm = Intermission::trmnl_or_new(context.fb.rect(), kind, &mut context);
                                         rq.add(RenderData::new(interm.id(), *interm.rect(), UpdateMode::Full));
                                         view.children_mut().push(Box::new(interm) as Box<dyn View>);
                                     }
diff --git a/crates/plato/src/app.rs b/crates/plato/src/app.rs
@@ -64,6 +64,7 @@ const CLOCK_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
 const BATTERY_REFRESH_INTERVAL: Duration = Duration::from_secs(299);
 const AUTO_SUSPEND_REFRESH_INTERVAL: Duration = Duration::from_secs(60);
 const SUSPEND_WAIT_DELAY: Duration = Duration::from_secs(15);
+const SUSPEND_WAIT_DELAY_TRMNL: Duration = Duration::from_secs(300);
 const PREPARE_SUSPEND_WAIT_DELAY: Duration = Duration::from_secs(3);
 
 struct Task {
@@ -350,7 +351,7 @@ pub fn run() -> Result<(), Error> {
                             resume(TaskId::Suspend, &mut tasks, view.as_mut(), &tx, &mut rq, &mut context);
                         } else {
                             view.handle_event(&Event::Suspend, &tx, &mut bus, &mut rq, &mut context);
-                            let interm = Intermission::new(context.fb.rect(), IntermKind::Suspend, &context);
+                            let interm = Intermission::trmnl_or_new(context.fb.rect(), IntermKind::Suspend, &mut context);
                             rq.add(RenderData::new(interm.id(), *interm.rect(), UpdateMode::Full));
                             schedule_task(TaskId::PrepareSuspend, Event::PrepareSuspend,
                                           PREPARE_SUSPEND_WAIT_DELAY, &tx, &mut tasks);
@@ -374,7 +375,7 @@ pub fn run() -> Result<(), Error> {
                         }
 
                         view.handle_event(&Event::Suspend, &tx, &mut bus, &mut rq, &mut context);
-                        let interm = Intermission::new(context.fb.rect(), IntermKind::Suspend, &context);
+                        let interm = Intermission::trmnl_or_new(context.fb.rect(), IntermKind::Suspend, &mut context);
                         rq.add(RenderData::new(interm.id(), *interm.rect(), UpdateMode::Full));
                         schedule_task(TaskId::PrepareSuspend, Event::PrepareSuspend,
                                       PREPARE_SUSPEND_WAIT_DELAY, &tx, &mut tasks);
@@ -398,6 +399,22 @@ pub fn run() -> Result<(), Error> {
                         }
                     },
                     DeviceEvent::NetUp => {
+                        if context.settings.trmnl.is_some()
+                            && tasks.iter().any(|t| t.id == TaskId::Suspend) {
+                            tasks.retain(|task| task.id != TaskId::Suspend);
+
+                            println!("Network is up, cancelling fallback suspend and preparing TRMNL refresh.");
+                            // destroy and recreate the Interm::Suspend Intermission
+                            if let Some(index) = locate::<Intermission>(view.as_ref()) {
+                                view.children_mut().remove(index);
+                                let new_interm = Intermission::trmnl_or_new(context.fb.rect(), IntermKind::Suspend, &mut context);
+                                rq.add(RenderData::new(new_interm.id(), *new_interm.rect(), UpdateMode::Full));
+                                view.children_mut().push(Box::new(new_interm) as Box<dyn View>);
+                            }
+
+                            schedule_task(TaskId::PrepareSuspend, Event::PrepareSuspend,
+                                          PREPARE_SUSPEND_WAIT_DELAY, &tx, &mut tasks);
+                        }
                         if tasks.iter().any(|task| task.id == TaskId::PrepareSuspend ||
                                                    task.id == TaskId::Suspend) {
                             continue;
@@ -586,6 +603,11 @@ pub fn run() -> Result<(), Error> {
             },
             Event::Suspend => {
                 if let Some(alarm_manager) = context.alarm_manager.as_mut() {
+                    if let Some(trmnl_client) = &context.trmnl_client {
+                        alarm_manager.schedule_alarm(AlarmType::TrmnlRefresh, trmnl_client.refresh_rate() as i64)
+                                     .map_err(|e| eprintln!("Can't schedule TRMNL refresh alarm: {:#}.", e))
+                                     .ok();
+                    }
                     if context.settings.auto_power_off > 0.0 && !alarm_manager.is_alarm_scheduled(AlarmType::AutoPowerOff) {
                         alarm_manager.schedule_alarm(AlarmType::AutoPowerOff, (context.settings.auto_power_off * 86400.0) as i64)
                                      .map_err(|e| eprintln!("Can't schedule auto power off alarm: {:#}.", e))
@@ -612,6 +634,18 @@ pub fn run() -> Result<(), Error> {
                         Ok(fired_alarms) => {
                             println!("Alarms fired: {:?}", fired_alarms);
 
+                            if fired_alarms.contains(&AlarmType::TrmnlRefresh) {
+                                if context.settings.wifi {
+                                    println!("TRMNL refresh time reached, enabling Wi-Fi to fetch new image");
+                                    Command::new("scripts/wifi-enable.sh").status().ok();
+                                    tasks.retain(|task| task.id != TaskId::Suspend);
+                                    schedule_task(TaskId::Suspend, Event::Suspend,
+                                                  SUSPEND_WAIT_DELAY_TRMNL, &tx, &mut tasks);
+                                } else {
+                                    println!("TRMNL refresh time reached, but Wi-Fi is disabled. Not enabling Wi-Fi to fetch new image.");
+                                }
+                            }
+
                             if fired_alarms.contains(&AlarmType::AutoPowerOff) {
                                 power_off(view.as_mut(), &mut history, &mut updating, &mut context);
                                 exit_status = ExitStatus::PowerOff;
@@ -962,7 +996,7 @@ pub fn run() -> Result<(), Error> {
                 let seconds = 60.0 * context.settings.auto_suspend;
                 if inactive_since.elapsed() > Duration::from_secs_f32(seconds) {
                     view.handle_event(&Event::Suspend, &tx, &mut bus, &mut rq, &mut context);
-                    let interm = Intermission::new(context.fb.rect(), IntermKind::Suspend, &context);
+                    let interm = Intermission::trmnl_or_new(context.fb.rect(), IntermKind::Suspend, &mut context);
                     rq.add(RenderData::new(interm.id(), *interm.rect(), UpdateMode::Full));
                     schedule_task(TaskId::PrepareSuspend, Event::PrepareSuspend,
                                   PREPARE_SUSPEND_WAIT_DELAY, &tx, &mut tasks);

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,7 @@ impl Rtc {`
`99`	`99`
`100`	`100`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]`
`101`	`101`	`pub enum AlarmType {`
	`102`	`+ TrmnlRefresh,`
`102`	`103`	`AutoPowerOff,`
`103`	`104`	`}`
`104`	`105`
Original file line number	Diff line number	Diff line change
`@@ -376,7 +376,7 @@ fn main() -> Result<(), Error> {`
`376`	`376`	`Scancode::C => IntermKind::Share,`
`377`	`377`	`_ => unreachable!(),`
`378`	`378`	`};`
`379`		`- let interm = Intermission::new(context.fb.rect(), kind, &context);`
	`379`	`+ let interm = Intermission::trmnl_or_new(context.fb.rect(), kind, &mut context);`
`380`	`380`	`rq.add(RenderData::new(interm.id(), *interm.rect(), UpdateMode::Full));`
`381`	`381`	`view.children_mut().push(Box::new(interm) as Box<dyn View>);`
`382`	`382`	`}`