Good enough

src/badge_display/mod.rs

···
     TextBox,
 };
 use gpio::Output;
-use heapless::String;
+use heapless::{String, Vec};
 use tinybmp::Bmp;
 use uc8151::LUT;
 use uc8151::WIDTH;
···
 
 use crate::{env::env_value, helpers::easy_format, Spi0Bus};
 
+pub type RECENT_WIFI_NETWORKS_VEC = Vec<String<32>, 4>;
+
 //Display state
 pub static SCREEN_TO_SHOW: blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<Screen>> =
     blocking_mutex::Mutex::new(RefCell::new(Screen::Badge));
+pub static RECENT_WIFI_NETWORKS: blocking_mutex::Mutex<
+    CriticalSectionRawMutex,
+    RefCell<RECENT_WIFI_NETWORKS_VEC>,
+> = blocking_mutex::Mutex::new(RefCell::new(RECENT_WIFI_NETWORKS_VEC::new()));
+
 pub static FORCE_SCREEN_REFRESH: AtomicBool = AtomicBool::new(true);
 pub static DISPLAY_CHANGED: AtomicBool = AtomicBool::new(false);
 pub static CURRENT_IMAGE: AtomicU8 = AtomicU8::new(0);
···
                 CHANGE_IMAGE.store(false, core::sync::atomic::Ordering::Relaxed);
             }
         } else {
-            if cycles_since_last_clear % 60 == 0 || force_screen_refresh {
+            if force_screen_refresh {
                 let top_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
                 top_bounds
                     .into_styled(
···
                     Err(_) => {
                         info!("Error updating display");
                     }
+                }
+
+                //write the wifi list
+                let mut y_offset = 24;
+                let wifi_list = RECENT_WIFI_NETWORKS.lock(|x| x.borrow().clone());
+                for wifi in wifi_list.iter() {
+                    // let wifi_text: String<64> = easy_format::<64>(format_args!("{}", wifi));
+                    let wifi_bounds = Rectangle::new(Point::new(0, y_offset), Size::new(WIDTH, 24));
+                    wifi_bounds
+                        .into_styled(
+                            PrimitiveStyleBuilder::default()
+                                .stroke_color(BinaryColor::Off)
+                                .fill_color(BinaryColor::On)
+                                .stroke_width(1)
+                                .build(),
+                        )
+                        .draw(&mut display)
+                        .unwrap();
+
+                    Text::new(wifi.trim(), Point::new(8, y_offset + 16), character_style)
+                        .draw(&mut display)
+                        .unwrap();
+
+                    let result = display
+                        .partial_update(wifi_bounds.try_into().unwrap())
+                        .await;
+                    match result {
+                        Ok(_) => {}
+                        Err(_) => {
+                            info!("Error updating display");
+                        }
+                    }
+                    y_offset += 24;
                 }
             }
         }

src/main.rs

···
 use badge_display::display_image::DisplayImage;
 use badge_display::{
     run_the_display, Screen, CHANGE_IMAGE, CURRENT_IMAGE, DISPLAY_CHANGED, FORCE_SCREEN_REFRESH,
-    RTC_TIME_STRING, SCREEN_TO_SHOW, WIFI_COUNT,
+    RECENT_WIFI_NETWORKS, RECENT_WIFI_NETWORKS_VEC, RTC_TIME_STRING, SCREEN_TO_SHOW, WIFI_COUNT,
 };
 use core::fmt::Write;
 use core::str::from_utf8;
···
             info!("Button B pressed");
             save.wifi_counted = 0;
             save.bssid.clear();
-            WIFI_COUNT.store(0, core::sync::atomic::Ordering::Relaxed);
+
+            SCREEN_TO_SHOW.lock(|screen| {
+                if *screen.borrow() == Screen::Badge {
+                    WIFI_COUNT.store(0, core::sync::atomic::Ordering::Relaxed);
+                }
+            });
+
+            let mut recent_networks = RECENT_WIFI_NETWORKS_VEC::new();
+            let mut scanner = control.scan(Default::default()).await;
+            while let Some(bss) = scanner.next().await {
+                process_bssid(bss.bssid, &mut save.wifi_counted, &mut save.bssid);
+                if recent_networks.len() < 8 {
+                    let possible_ssid = core::str::from_utf8(&bss.ssid);
+                    match possible_ssid {
+                        Ok(ssid) => {
+                            let ssid_string = easy_format::<32>(format_args!("{}", ssid.trim()));
+                            if recent_networks.contains(&ssid_string) {
+                                continue;
+                            }
+                            let _ = recent_networks.push(ssid_string);
+                        }
+                        Err(_) => {
+                            continue;
+                        }
+                    }
+                }
+            }
+            RECENT_WIFI_NETWORKS.lock(|recent_networks_vec| {
+                recent_networks_vec.replace(recent_networks);
+            });
+
             FORCE_SCREEN_REFRESH.store(true, core::sync::atomic::Ordering::Relaxed);
             Timer::after(Duration::from_millis(500)).await;
             current_cycle += 500;