Binary chooser

purduehackers · Feb 20, 2025 · fe0dc93 · fe0dc93
1 parent 956667f
commit fe0dc93
Show file tree

Hide file tree

Showing 2 changed files with 74 additions and 55 deletions.
diff --git a/src/main.rs b/src/main.rs
@@ -1,13 +1,13 @@
 #![feature(type_alias_impl_trait)]
 
 use build_time::build_time_utc;
-use chrono::{Duration, Local};
+use chrono::Local;
 use chrono_tz::US::Eastern;
 use embassy_time::Timer;
 use esp_idf_svc::{
     eventloop::EspSystemEventLoop,
     hal::{
-        gpio::{Gpio15, Gpio36, Input, Level, Output, PinDriver},
+        gpio::{Gpio15, Gpio36, Input, Output, PinDriver},
         ledc::{config::TimerConfig, LedcDriver, LedcTimerDriver},
         peripherals::Peripherals,
         task::block_on,
@@ -26,18 +26,16 @@ use sign_firmware::{
     net::{connect_to_network, self_update},
     Block, Leds,
 };
-#[cfg(feature = "interactive")]
-use sign_firmware::printer;
 
 extern crate alloc;
 
 async fn amain(
     mut leds: Leds,
     mut wifi: AsyncWifi<EspWifi<'static>>,
+    #[allow(unused_variables)] button_switch: PinDriver<'static, Gpio36, Input>,
     #[allow(unused_variables)]
-    button_switch: PinDriver<'static, Gpio36, Input>,
-    #[allow(unused_variables)]
-    button_led: PinDriver<'static, Gpio15, Output>,
+    #[allow(unused_mut)]
+    mut button_led: PinDriver<'static, Gpio15, Output>,
 ) {
     // Red before wifi
     leds.set_all_colors(Rgb::new(255, 0, 0));
@@ -53,7 +51,7 @@ async fn amain(
     self_update(&mut leds).await.expect("Self-update to work");
 
     #[cfg(feature = "interactive")]
-    let mut interactive_state = InteractiveState {
+    let mut interactive_state = interactive::InteractiveState {
         last_led_change: Local::now(),
         last_time: LightningTime::from(Local::now().with_timezone(&Eastern).time()),
         button_pressed: false,
@@ -62,7 +60,13 @@ async fn amain(
         let time = LightningTime::from(Local::now().with_timezone(&Eastern).time());
 
         #[cfg(feature = "interactive")]
-        interactive(&mut interactive_state, &mut button_led, &button_switch, time).await;
+        interactive::interactive(
+            &mut interactive_state,
+            &mut button_led,
+            &button_switch,
+            time,
+        )
+        .await;
 
         set_colors(&time.colors(), &mut leds);
 
@@ -71,60 +75,66 @@ async fn amain(
 }
 
 #[cfg(feature = "interactive")]
-async fn interactive(
-    InteractiveState {
-        last_led_change,
-        last_time,
-        button_pressed,
-    }: &mut InteractiveState,
-    button_led: &mut PinDriver<'static, Gpio15, Output>,
-    button_switch: &PinDriver<'static, Gpio36, Input>,
-    time: LightningTime,
-) {
-    fn midnight(time: &LightningTime) -> bool {
-        time.bolts == 0 && time.zaps == 0 && time.sparks == 0 && time.charges == 0
-    }
-
-    if midnight(&time) && !midnight(&last_time) {
-        if let Err(e) = printer::post_event(printer::PrinterEvent::Zero).await {
-            log::error!("ZERO: Printer error: {e}");
-        }
-    } else if time.bolts != last_time.bolts {
-        if let Err(e) = printer::post_event(printer::PrinterEvent::NewBolt(time.bolts)).await {
-            log::error!("BOLT: Printer error: {e}");
+mod interactive {
+    use super::*;
+    use chrono::Duration;
+    use esp_idf_svc::hal::gpio::Level;
+    use sign_firmware::printer;
+
+    pub async fn interactive(
+        InteractiveState {
+            last_led_change,
+            last_time,
+            button_pressed,
+        }: &mut InteractiveState,
+        button_led: &mut PinDriver<'static, Gpio15, Output>,
+        button_switch: &PinDriver<'static, Gpio36, Input>,
+        time: LightningTime,
+    ) {
+        fn midnight(time: &LightningTime) -> bool {
+            time.bolts == 0 && time.zaps == 0 && time.sparks == 0 && time.charges == 0
         }
-    } else if time.zaps != last_time.zaps {
-        if let Err(e) = printer::post_event(printer::PrinterEvent::NewZap(time.zaps)).await {
-            log::error!("ZAP: Printer error: {e}");
+
+        if midnight(&time) && !midnight(&last_time) {
+            if let Err(e) = printer::post_event(printer::PrinterEvent::Zero).await {
+                log::error!("ZERO: Printer error: {e}");
+            }
+        } else if time.bolts != last_time.bolts {
+            if let Err(e) = printer::post_event(printer::PrinterEvent::NewBolt(time.bolts)).await {
+                log::error!("BOLT: Printer error: {e}");
+            }
+        } else if time.zaps != last_time.zaps {
+            if let Err(e) = printer::post_event(printer::PrinterEvent::NewZap(time.zaps)).await {
+                log::error!("ZAP: Printer error: {e}");
+            }
         }
-    }
 
-    match (button_switch.get_level(), *button_pressed) {
-        (Level::High, false) => {
-            if let Err(e) = printer::post_event(printer::PrinterEvent::ButtonPressed).await {
-                log::error!("BUTTON PRESSED: Printer error: {e}");
+        match (button_switch.get_level(), *button_pressed) {
+            (Level::High, false) => {
+                if let Err(e) = printer::post_event(printer::PrinterEvent::ButtonPressed).await {
+                    log::error!("BUTTON PRESSED: Printer error: {e}");
+                }
+                *button_pressed = true;
+            }
+            (Level::Low, true) => {
+                *button_pressed = false;
             }
-            *button_pressed = true;
+            _ => {}
         }
-        (Level::Low, true) => {
-            *button_pressed = false;
+
+        if Local::now() - *last_led_change > Duration::seconds(1) {
+            button_led.toggle().unwrap();
+            *last_led_change = Local::now();
         }
-        _ => {}
-    }
 
-    if Local::now() - *last_led_change > Duration::seconds(1) {
-        button_led.toggle().unwrap();
-        *last_led_change = Local::now();
+        *last_time = time;
     }
 
-    *last_time = time;
-}
-
-#[cfg(feature = "interactive")]
-struct InteractiveState {
-    last_led_change: chrono::DateTime<Local>,
-    last_time: LightningTime,
-    button_pressed: bool,
+    pub struct InteractiveState {
+        pub last_led_change: chrono::DateTime<Local>,
+        pub last_time: LightningTime,
+        pub button_pressed: bool,
+    }
 }
 
 fn set_colors(colors: &LightningTimeColors, leds: &mut Leds) {

diff --git a/src/net.rs b/src/net.rs
@@ -28,6 +28,7 @@ struct GithubResponse {
 #[derive(Debug, serde::Deserialize)]
 struct GithubAsset {
     browser_download_url: String,
+    name: String,
 }
 
 pub async fn generate_tls(url: &str) -> anyhow::Result<EspAsyncTls<EspTlsSocket>> {
@@ -176,7 +177,15 @@ pub async fn self_update(leds: &mut Leds) -> anyhow::Result<()> {
         // Grab new release and update
         let url = manifest
             .assets
-            .first()
+            .into_iter()
+            .find(|asset| {
+                asset.name
+                    == if IS_INTERACTIVE {
+                        "sign-firmware-interactive.bin"
+                    } else {
+                        "sign-firmware.bin"
+                    }
+            })
             .expect("release to contain assets")
             .browser_download_url
             .clone();