Real time and wifi counting

Cargo.lock

···
 ]
 
 [[package]]
+name = "cobs"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
+
+[[package]]
 name = "codespan-reporting"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "pio",
  "pio-proc",
  "portable-atomic",
+ "postcard",
  "rand",
  "reqwless",
  "serde",
···
  "atomic-polyfill",
  "hash32 0.2.1",
  "rustc_version 0.4.0",
+ "serde",
  "spin",
  "stable_deref_trait",
 ]
···
 checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
 dependencies = [
  "critical-section",
+]
+
+[[package]]
+name = "postcard"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f7f0a8d620d71c457dd1d47df76bb18960378da56af4527aaa10f515eee732e"
+dependencies = [
+ "cobs",
+ "heapless 0.7.17",
+ "serde",
 ]
 
 [[package]]

Cargo.toml

···
 embedded-text = "0.7.0"
 tinybmp = "0.5.0"
 shtcx = "1.0.0"
+postcard = "1.0.8"
 
 [profile.release]
 debug = 2

src/badge_display/mod.rs

···
 use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
 use embassy_rp::gpio;
 use embassy_rp::gpio::Input;
-use embassy_sync::{
-    blocking_mutex::{self, raw::CriticalSectionRawMutex},
-    mutex,
-};
+use embassy_sync::blocking_mutex::{self, raw::CriticalSectionRawMutex};
 use embassy_time::{Delay, Duration, Timer};
 use embedded_graphics::{
     image::Image,
     mono_font::{ascii::*, MonoTextStyle},
-    pixelcolor::{BinaryColor, Rgb565},
+    pixelcolor::BinaryColor,
     prelude::*,
     primitives::{PrimitiveStyle, PrimitiveStyleBuilder, Rectangle},
     text::Text,
···
 use gpio::Output;
 use heapless::String;
 use tinybmp::Bmp;
+use uc8151::asynch::Uc8151;
 use uc8151::LUT;
 use uc8151::WIDTH;
-use uc8151::{asynch::Uc8151, UpdateRegion};
 use {defmt_rtt as _, panic_probe as _};
 
 use crate::{env::env_value, helpers::easy_format, Spi0Bus};
···
     blocking_mutex::Mutex::new(RefCell::new(String::<8>::new()));
 pub static TEMP: AtomicU8 = AtomicU8::new(0);
 pub static HUMIDITY: AtomicU8 = AtomicU8::new(0);
-pub static HOUR: AtomicU8 = AtomicU8::new(10);
-pub static MINUTE: AtomicU8 = AtomicU8::new(57);
-pub static SECOND: AtomicU8 = AtomicU8::new(0);
 
 #[embassy_executor::task]
 pub async fn run_the_display(
···
         }
 
         //Updates the top bar
-        //Runs every 30 cycles/15 seconds and first run
-        if cycles_since_last_clear % 30 == 0 || first_run {
+        //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 {}% Count: {}", temp, humidity, count));
+            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(
···
                     info!("Error updating display");
                 }
             }
-
-            WIFI_COUNT.store(count + 1, core::sync::atomic::Ordering::Relaxed);
         }
 
         //Runs every 120 cycles/60 seconds and first run

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 core::fmt::Write;
 use core::str::from_utf8;
-use core::time;
-
-use badge_display::display_image::DisplayImage;
-use badge_display::{run_the_display, CHANGE_IMAGE, CURRENT_IMAGE, RTC_TIME_STRING};
 use cyw43_driver::setup_cyw43;
-use cyw43_pio::PioSpi;
 use defmt::info;
 use defmt::*;
 use embassy_executor::Spawner;
···
 use embassy_net::tcp::client::{TcpClient, TcpClientState};
 use embassy_net::{Stack, StackResources};
 use embassy_rp::clocks::RoscRng;
+use embassy_rp::flash::Async;
 use embassy_rp::gpio;
 use embassy_rp::gpio::Input;
 use embassy_rp::peripherals::{DMA_CH0, PIO0, SPI0};
···
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::mutex::Mutex;
 use embassy_time::{Duration, Timer};
+use embedded_hal_1::digital::OutputPin;
 use env::env_value;
 use gpio::{Level, Output, Pull};
-use heapless::Vec;
+use heapless::{String, Vec};
 use helpers::easy_format;
 use rand::RngCore;
 use reqwless::client::{HttpClient, TlsConfig, TlsVerify};
 use reqwless::request::Method;
+use save::{read_postcard_from_flash, save_postcard_to_flash, Save};
 use serde::Deserialize;
 use static_cell::StaticCell;
 use temp_sensor::run_the_temp_sensor;
···
 mod cyw43_driver;
 mod env;
 mod helpers;
+mod save;
 mod temp_sensor;
 
 type Spi0Bus = Mutex<NoopRawMutex, Spi<'static, SPI0, spi::Async>>;
 
+const BSSID_LEN: usize = 1_000;
+const ADDR_OFFSET: u32 = 0x100000;
+const SAVE_OFFSET: u32 = 0x00;
+
+const FLASH_SIZE: usize = 2 * 1024 * 1024;
+
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
+    let mut user_led = Output::new(p.PIN_22, Level::High);
+    user_led.set_high();
+
     let (net_device, mut control) = setup_cyw43(
         p.PIO0, p.PIN_23, p.PIN_24, p.PIN_25, p.PIN_29, p.DMA_CH0, spawner,
     )
···
     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_b = Input::new(p.PIN_13, Pull::Down);
     let btn_c = Input::new(p.PIN_14, Pull::Down);
 
     let spi = Spi::new(
···
         }
     }
 
-    //
-
+    //Set up saving
+    let mut flash = embassy_rp::flash::Flash::<_, Async, FLASH_SIZE>::new(p.FLASH, p.DMA_CH3);
+    let mut save: Save = read_postcard_from_flash(ADDR_OFFSET, &mut flash, SAVE_OFFSET).unwrap();
+    WIFI_COUNT.store(save.wifi_counted, core::sync::atomic::Ordering::Relaxed);
     //Task spawning
     spawner.must_spawn(run_the_temp_sensor(p.I2C0, p.PIN_5, p.PIN_4));
     spawner.must_spawn(run_the_display(spi_bus, cs, dc, busy, reset));
 
     //Input loop
+    let cycle = Duration::from_millis(100);
+    let mut current_cycle = 0;
+    //5 minutes
+    let reset_cycle = 300_000;
+    //Turn off led to signify that the badge is ready
+    user_led.set_low();
+
     loop {
         //Change Image Button
         if btn_c.is_high() {
···
             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_b.is_high() {
+            user_led.toggle();
+            Timer::after(Duration::from_millis(500)).await;
+            current_cycle += 500;
             continue;
         }
 
···
                 rtc_time_string.borrow_mut().push_str("No Wifi").unwrap();
             });
         }
-
-        Timer::after(Duration::from_millis(100)).await;
+        if current_cycle == 0 {
+            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);
+            }
+            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;
+        }
+        current_cycle += 1;
+        Timer::after(cycle).await;
     }
 }
 
···
 struct TimeApiResponse<'a> {
     datetime: &'a str,
     day_of_week: u8,
-    // other fields as needed
+}
+
+fn process_bssid(bssid: [u8; 6], wifi_counted: &mut u32, bssids: &mut Vec<String<17>, BSSID_LEN>) {
+    let bssid_str = format_bssid(bssid);
+    if !bssids.contains(&bssid_str) {
+        *wifi_counted += 1;
+        info!("bssid: {:x}", bssid_str);
+        let result = bssids.push(bssid_str);
+        if result.is_err() {
+            info!("bssid list full");
+            bssids.clear();
+        }
+    }
+}
+
+fn format_bssid(bssid: [u8; 6]) -> String<17> {
+    let mut s = String::new();
+    for (i, byte) in bssid.iter().enumerate() {
+        if i != 0 {
+            let _ = s.write_char(':');
+        }
+        core::fmt::write(&mut s, format_args!("{:02x}", byte)).unwrap();
+    }
+    s
 }

src/save.rs

···
+use crate::FLASH_SIZE;
+use embassy_rp::flash::{Async, ERASE_SIZE};
+use embassy_rp::peripherals::FLASH;
+use heapless::{String, Vec};
+use postcard::{from_bytes, to_slice};
+use serde::{Deserialize, Serialize};
+use {defmt_rtt as _, panic_probe as _};
+
+const BSSID_LEN: usize = 1_000;
+
+pub fn save_postcard_to_flash(
+    base_offset: u32,
+    flash: &mut embassy_rp::flash::Flash<'_, FLASH, Async, FLASH_SIZE>,
+    offset: u32,
+    data: &Save,
+) -> Result<(), &'static str> {
+    let mut buf = [0u8; ERASE_SIZE];
+
+    let mut write_buf = [0u8; ERASE_SIZE];
+    let written = to_slice(data, &mut write_buf).map_err(|_| "Serialization error")?;
+
+    if written.len() > ERASE_SIZE {
+        return Err("Data too large for flash sector");
+    }
+
+    flash
+        .blocking_erase(
+            base_offset + offset,
+            base_offset + offset + ERASE_SIZE as u32,
+        )
+        .map_err(|_| "Erase error")?;
+
+    buf[..written.len()].copy_from_slice(&written);
+
+    flash
+        .blocking_write(base_offset + offset, &buf)
+        .map_err(|_| "Write error")?;
+
+    Ok(())
+}
+
+pub fn read_postcard_from_flash(
+    base_offset: u32,
+    flash: &mut embassy_rp::flash::Flash<'_, FLASH, Async, FLASH_SIZE>,
+    offset: u32,
+) -> Result<Save, &'static str> {
+    let mut buf = [0u8; ERASE_SIZE];
+
+    flash
+        .blocking_read(base_offset + offset, &mut buf)
+        .map_err(|_| "Read error")?;
+
+    let data = from_bytes::<Save>(&buf).map_err(|_| "Deserialization error")?;
+
+    Ok(data)
+}
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
+pub struct Save {
+    pub wifi_counted: u32,
+    pub bssid: Vec<String<17>, BSSID_LEN>,
+}

src/temp_sensor.rs

···
             combined.humidity.as_percent() as u8,
             core::sync::atomic::Ordering::Relaxed,
         );
-        Timer::after_secs(120).await;
+        Timer::after_secs(30).await;
     }
 }