WIp of multiple screens

src/badge_display/mod.rs

···
 use gpio::Output;
 use heapless::String;
 use tinybmp::Bmp;
-use uc8151::asynch::Uc8151;
 use uc8151::LUT;
 use uc8151::WIDTH;
+use uc8151::{asynch::Uc8151, HEIGHT};
 use {defmt_rtt as _, panic_probe as _};
 
 use crate::{env::env_value, helpers::easy_format, Spi0Bus};
 
 //Display state
+pub static SCREEN_TO_SHOW: blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<Screen>> =
+    blocking_mutex::Mutex::new(RefCell::new(Screen::Badge));
+pub static DISPLAY_CHANGED: AtomicBool = AtomicBool::new(false);
 pub static CURRENT_IMAGE: AtomicU8 = AtomicU8::new(0);
 pub static CHANGE_IMAGE: AtomicBool = AtomicBool::new(true);
 pub static WIFI_COUNT: AtomicU32 = AtomicU32::new(0);
···
     blocking_mutex::Mutex::new(RefCell::new(String::<8>::new()));
 pub static TEMP: AtomicU8 = AtomicU8::new(0);
 pub static HUMIDITY: AtomicU8 = AtomicU8::new(0);
+
+#[derive(Debug, Clone, Copy, PartialEq, defmt::Format)]
+pub enum Screen {
+    Badge,
+    WifiList,
+}
 
 #[embassy_executor::task]
 pub async fn run_the_display(
···
     //New start every 120 cycles or 60 seconds
     let cycles_to_clear_at: i32 = 120;
     let mut cycles_since_last_clear = 0;
-
+    let mut current_screen = Screen::Badge;
     loop {
         //Timed based display events
-
-        //Runs every second;
-        if cycles_since_last_clear % 2 == 0 {
-            // update_time_values_from_cycles();
+        if DISPLAY_CHANGED.load(core::sync::atomic::Ordering::Relaxed) {
+            let clear_rectangle = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, HEIGHT));
+            clear_rectangle
+                .into_styled(PrimitiveStyle::with_fill(BinaryColor::On))
+                .draw(&mut display)
+                .unwrap();
+            let _ = display.update().await;
+            DISPLAY_CHANGED.store(false, core::sync::atomic::Ordering::Relaxed);
+            first_run = true;
         }
 
-        //Updates the top bar
-        //Runs every 60 cycles/30 seconds and first run
-        if cycles_since_last_clear % 60 == 0 || first_run {
-            let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
-            let temp = TEMP.load(core::sync::atomic::Ordering::Relaxed);
-            let humidity = HUMIDITY.load(core::sync::atomic::Ordering::Relaxed);
-            let top_text: String<64> = easy_format::<64>(format_args!(
-                "{}F {}% Wifi found: {}",
-                temp, humidity, count
-            ));
-            let top_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
-            top_bounds
-                .into_styled(
-                    PrimitiveStyleBuilder::default()
-                        .stroke_color(BinaryColor::Off)
-                        .fill_color(BinaryColor::On)
-                        .stroke_width(1)
-                        .build(),
-                )
-                .draw(&mut display)
-                .unwrap();
+        SCREEN_TO_SHOW.lock(|x| current_screen = *x.borrow());
+        info!("Current Screen: {:?}", current_screen);
+        if current_screen == Screen::Badge {
+            //Updates the top bar
+            //Runs every 60 cycles/30 seconds and first run
+            if cycles_since_last_clear % 60 == 0 || first_run {
+                let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
+                let temp = TEMP.load(core::sync::atomic::Ordering::Relaxed);
+                let humidity = HUMIDITY.load(core::sync::atomic::Ordering::Relaxed);
+                let top_text: String<64> = easy_format::<64>(format_args!(
+                    "{}F {}% Wifi found: {}",
+                    temp, humidity, count
+                ));
+                let top_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
+                top_bounds
+                    .into_styled(
+                        PrimitiveStyleBuilder::default()
+                            .stroke_color(BinaryColor::Off)
+                            .fill_color(BinaryColor::On)
+                            .stroke_width(1)
+                            .build(),
+                    )
+                    .draw(&mut display)
+                    .unwrap();
 
-            Text::new(top_text.as_str(), Point::new(8, 16), character_style)
-                .draw(&mut display)
-                .unwrap();
+                Text::new(top_text.as_str(), Point::new(8, 16), character_style)
+                    .draw(&mut display)
+                    .unwrap();
 
-            // Draw the text box.
-            let result = display.partial_update(top_bounds.try_into().unwrap()).await;
-            match result {
-                Ok(_) => {}
-                Err(_) => {
-                    info!("Error updating display");
+                // Draw the text box.
+                let result = display.partial_update(top_bounds.try_into().unwrap()).await;
+                match result {
+                    Ok(_) => {}
+                    Err(_) => {
+                        info!("Error updating display");
+                    }
                 }
             }
-        }
 
-        //Runs every 120 cycles/60 seconds and first run
-        if cycles_since_last_clear == 0 {
-            let mut time_text: String<8> = String::<8>::new();
+            //Runs every 120 cycles/60 seconds and first run
+            if cycles_since_last_clear == 0 || first_run {
+                let mut time_text: String<8> = String::<8>::new();
+
+                let time_box_rectangle_location = Point::new(0, 96);
+                RTC_TIME_STRING.lock(|x| {
+                    time_text.push_str(x.borrow().as_str()).unwrap();
+                });
 
-            let time_box_rectangle_location = Point::new(0, 96);
-            RTC_TIME_STRING.lock(|x| {
-                time_text.push_str(x.borrow().as_str()).unwrap();
-            });
+                //The bounds of the box for time and refresh area
+                let time_bounds = Rectangle::new(time_box_rectangle_location, Size::new(88, 24));
+                time_bounds
+                    .into_styled(
+                        PrimitiveStyleBuilder::default()
+                            .stroke_color(BinaryColor::Off)
+                            .fill_color(BinaryColor::On)
+                            .stroke_width(1)
+                            .build(),
+                    )
+                    .draw(&mut display)
+                    .unwrap();
 
-            //The bounds of the box for time and refresh area
-            let time_bounds = Rectangle::new(time_box_rectangle_location, Size::new(88, 24));
-            time_bounds
-                .into_styled(
-                    PrimitiveStyleBuilder::default()
-                        .stroke_color(BinaryColor::Off)
-                        .fill_color(BinaryColor::On)
-                        .stroke_width(1)
-                        .build(),
+                //Adding a y offset to the box location to fit inside the box
+                Text::new(
+                    time_text.as_str(),
+                    (
+                        time_box_rectangle_location.x + 8,
+                        time_box_rectangle_location.y + 16,
+                    )
+                        .into(),
+                    character_style,
                 )
                 .draw(&mut display)
                 .unwrap();
 
-            //Adding a y offset to the box location to fit inside the box
-            Text::new(
-                time_text.as_str(),
-                (
-                    time_box_rectangle_location.x + 8,
-                    time_box_rectangle_location.y + 16,
-                )
-                    .into(),
-                character_style,
-            )
-            .draw(&mut display)
-            .unwrap();
-
-            let result = display
-                .partial_update(time_bounds.try_into().unwrap())
-                .await;
-            match result {
-                Ok(_) => {}
-                Err(_) => {
-                    info!("Error updating display");
+                let result = display
+                    .partial_update(time_bounds.try_into().unwrap())
+                    .await;
+                match result {
+                    Ok(_) => {}
+                    Err(_) => {
+                        info!("Error updating display");
+                    }
                 }
             }
-        }
 
-        //Manually triggered display events
+            //Manually triggered display events
 
-        if CHANGE_IMAGE.load(core::sync::atomic::Ordering::Relaxed) {
-            let current_image = get_current_image();
-            let tga: Bmp<BinaryColor> = Bmp::from_slice(&current_image.image()).unwrap();
-            let image = Image::new(&tga, current_image.image_location());
-            //clear image location by writing a white rectangle over previous image location
-            let clear_rectangle = Rectangle::new(
-                current_image.previous().image_location(),
-                Size::new(157, 101),
-            );
-            clear_rectangle
-                .into_styled(PrimitiveStyle::with_fill(BinaryColor::On))
-                .draw(&mut display)
-                .unwrap();
+            if CHANGE_IMAGE.load(core::sync::atomic::Ordering::Relaxed) || first_run {
+                let current_image = get_current_image();
+                let tga: Bmp<BinaryColor> = Bmp::from_slice(&current_image.image()).unwrap();
+                let image = Image::new(&tga, current_image.image_location());
+                //clear image location by writing a white rectangle over previous image location
+                let clear_rectangle = Rectangle::new(
+                    current_image.previous().image_location(),
+                    Size::new(157, 101),
+                );
+                clear_rectangle
+                    .into_styled(PrimitiveStyle::with_fill(BinaryColor::On))
+                    .draw(&mut display)
+                    .unwrap();
 
-            let _ = image.draw(&mut display);
-            //TODO need to look up the reginal area display
-            let _ = display.update().await;
-            CHANGE_IMAGE.store(false, core::sync::atomic::Ordering::Relaxed);
+                let _ = image.draw(&mut display);
+                //TODO need to look up the reginal area display
+                let _ = display.update().await;
+                CHANGE_IMAGE.store(false, core::sync::atomic::Ordering::Relaxed);
+            }
+        } else {
+            if cycles_since_last_clear % 60 == 0 || first_run {
+                let top_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
+                top_bounds
+                    .into_styled(
+                        PrimitiveStyleBuilder::default()
+                            .stroke_color(BinaryColor::Off)
+                            .fill_color(BinaryColor::On)
+                            .stroke_width(1)
+                            .build(),
+                    )
+                    .draw(&mut display)
+                    .unwrap();
+
+                let top_text: String<64> = easy_format::<64>(format_args!(
+                    "Wifi found: {}",
+                    WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed)
+                ));
+
+                Text::new(top_text.as_str(), Point::new(8, 16), character_style)
+                    .draw(&mut display)
+                    .unwrap();
+
+                let result = display.partial_update(top_bounds.try_into().unwrap()).await;
+                match result {
+                    Ok(_) => {}
+                    Err(_) => {
+                        info!("Error updating display");
+                    }
+                }
+            }
         }
 
         cycles_since_last_clear += 1;

src/main.rs

···
 #![no_std]
 #![no_main]
 use badge_display::display_image::DisplayImage;
-use badge_display::{run_the_display, CHANGE_IMAGE, CURRENT_IMAGE, RTC_TIME_STRING, WIFI_COUNT};
+use badge_display::{
+    run_the_display, Screen, CHANGE_IMAGE, CURRENT_IMAGE, DISPLAY_CHANGED, RTC_TIME_STRING,
+    SCREEN_TO_SHOW, WIFI_COUNT,
+};
 use core::fmt::Write;
 use core::str::from_utf8;
 use cyw43_driver::setup_cyw43;
···
     let cs = Output::new(cs, Level::High);
     let busy = Input::new(busy, Pull::Up);
 
-    let _btn_up = Input::new(p.PIN_15, Pull::Down);
-    let _btn_down = Input::new(p.PIN_11, Pull::Down);
-    let _btn_a = Input::new(p.PIN_12, Pull::Down);
+    let btn_up = Input::new(p.PIN_15, Pull::Down);
+    let btn_down = Input::new(p.PIN_11, Pull::Down);
+    let btn_a = Input::new(p.PIN_12, Pull::Down);
     let btn_b = Input::new(p.PIN_13, Pull::Down);
     let btn_c = Input::new(p.PIN_14, Pull::Down);
 
···
             continue;
         }
 
+        if btn_a.is_high() {
+            info!("Button A pressed");
+            user_led.toggle();
+            Timer::after(Duration::from_millis(500)).await;
+            current_cycle += 500;
+            continue;
+        }
+
+        if btn_down.is_high() {
+            info!("Button Down pressed");
+            SCREEN_TO_SHOW.lock(|screen| {
+                screen.replace(Screen::WifiList);
+            });
+            DISPLAY_CHANGED.store(true, core::sync::atomic::Ordering::Relaxed);
+            Timer::after(Duration::from_millis(500)).await;
+            current_cycle += 500;
+            continue;
+        }
+
+        if btn_up.is_high() {
+            info!("Button Up pressed");
+            SCREEN_TO_SHOW.lock(|screen| {
+                screen.replace(Screen::Badge);
+            });
+            DISPLAY_CHANGED.store(true, core::sync::atomic::Ordering::Relaxed);
+            Timer::after(Duration::from_millis(500)).await;
+            current_cycle += 500;
+            continue;
+        }
+
         if btn_b.is_high() {
             info!("Button B pressed");
-            user_led.toggle();
+            save.wifi_counted = 0;
+            save.bssid.clear();
+            WIFI_COUNT.store(0, core::sync::atomic::Ordering::Relaxed);
             Timer::after(Duration::from_millis(500)).await;
             current_cycle += 500;
             continue;