Good enough

src/badge_display/mod.rs

···
 
 use crate::{env::env_value, helpers::easy_format, Spi0Bus};
 
-pub type RECENT_WIFI_NETWORKS_VEC = Vec<String<32>, 4>;
+pub type RecentWifiNetworksVec = 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()));
+    RefCell<RecentWifiNetworksVec>,
+> = blocking_mutex::Mutex::new(RefCell::new(RecentWifiNetworksVec::new()));
 
 pub static FORCE_SCREEN_REFRESH: AtomicBool = AtomicBool::new(true);
 pub static DISPLAY_CHANGED: AtomicBool = AtomicBool::new(false);
···
         }
 
         SCREEN_TO_SHOW.lock(|x| current_screen = *x.borrow());
-        info!("Current Screen: {:?}", current_screen);
+        // info!("Current Screen: {:?}", current_screen);
         if current_screen == Screen::Badge {
             if force_screen_refresh {
                 // Draw the text box.
···
             //Runs every 60 cycles/30 seconds and first run
             if cycles_since_last_clear % 60 == 0 || force_screen_refresh {
                 let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
+                info!("Wifi count: {}", count);
                 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!(

src/main.rs

···
 #![no_main]
 use badge_display::display_image::DisplayImage;
 use badge_display::{
-    run_the_display, Screen, CHANGE_IMAGE, CURRENT_IMAGE, DISPLAY_CHANGED, FORCE_SCREEN_REFRESH,
-    RECENT_WIFI_NETWORKS, RECENT_WIFI_NETWORKS_VEC, RTC_TIME_STRING, SCREEN_TO_SHOW, WIFI_COUNT,
+    run_the_display, RecentWifiNetworksVec, Screen, CHANGE_IMAGE, CURRENT_IMAGE, DISPLAY_CHANGED,
+    FORCE_SCREEN_REFRESH, RECENT_WIFI_NETWORKS, RTC_TIME_STRING, SCREEN_TO_SHOW, WIFI_COUNT,
 };
 use core::fmt::Write;
 use core::str::from_utf8;
···
     //Input loop
     let cycle = Duration::from_millis(100);
     let mut current_cycle = 0;
-    //5 minutes
-    let reset_cycle = 300_000;
+    let mut time_to_scan = true;
+    //5 minutes(ish) idk it's late and my math is so bad rn
+    let reset_cycle = 3_000;
     //Turn off led to signify that the badge is ready
     user_led.set_low();
 
···
             CURRENT_IMAGE.store(new_image.as_u8(), core::sync::atomic::Ordering::Relaxed);
             CHANGE_IMAGE.store(true, core::sync::atomic::Ordering::Relaxed);
             Timer::after(Duration::from_millis(500)).await;
-            current_cycle += 500;
             continue;
         }
 
         if btn_a.is_high() {
+            println!("{:?}", current_cycle);
             info!("Button A pressed");
             user_led.toggle();
             Timer::after(Duration::from_millis(500)).await;
-            current_cycle += 500;
             continue;
         }
 
···
             });
             DISPLAY_CHANGED.store(true, core::sync::atomic::Ordering::Relaxed);
             Timer::after(Duration::from_millis(500)).await;
-            current_cycle += 500;
             continue;
         }
 
···
             });
             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");
-            save.wifi_counted = 0;
-            save.bssid.clear();
 
             SCREEN_TO_SHOW.lock(|screen| {
                 if *screen.borrow() == Screen::Badge {
+                    //IF on badge screen and b pressed reset wifi count
+                    save.wifi_counted = 0;
+                    save.bssid.clear();
                     WIFI_COUNT.store(0, core::sync::atomic::Ordering::Relaxed);
+                    current_cycle = 0;
                 }
             });
 
-            let mut recent_networks = RECENT_WIFI_NETWORKS_VEC::new();
+            let mut recent_networks = RecentWifiNetworksVec::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);
···
                     let possible_ssid = core::str::from_utf8(&bss.ssid);
                     match possible_ssid {
                         Ok(ssid) => {
+                            info!("ssid: {}", ssid);
                             let ssid_string = easy_format::<32>(format_args!("{}", ssid.trim()));
                             if recent_networks.contains(&ssid_string) {
                                 continue;
···
 
             FORCE_SCREEN_REFRESH.store(true, core::sync::atomic::Ordering::Relaxed);
             Timer::after(Duration::from_millis(500)).await;
-            current_cycle += 500;
+
             continue;
         }
 
···
                 rtc_time_string.borrow_mut().push_str("No Wifi").unwrap();
             });
         }
-        if current_cycle == 0 {
+        if time_to_scan {
+            info!("Scanning for wifi networks");
+            time_to_scan = false;
             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);
-                let ssid = core::str::from_utf8(&bss.ssid).unwrap();
-                info!("ssid: {}", ssid);
             }
+            WIFI_COUNT.store(save.wifi_counted, core::sync::atomic::Ordering::Relaxed);
             save_postcard_to_flash(ADDR_OFFSET, &mut flash, SAVE_OFFSET, &save).unwrap();
-            WIFI_COUNT.store(save.wifi_counted, core::sync::atomic::Ordering::Relaxed);
             info!("wifi_counted: {}", save.wifi_counted);
         }
         if current_cycle >= reset_cycle {
             current_cycle = 0;
+            time_to_scan = true;
         }
         current_cycle += 1;
         Timer::after(cycle).await;
···
     let bssid_str = format_bssid(bssid);
     if !bssids.contains(&bssid_str) {
         *wifi_counted += 1;
-        info!("bssid: {:x}", bssid_str);
+        WIFI_COUNT.store(*wifi_counted, core::sync::atomic::Ordering::Relaxed);
+        // info!("bssid: {:x}", bssid_str);
         let result = bssids.push(bssid_str);
         if result.is_err() {
             info!("bssid list full");