Good enough

src/main.rs

···
 use core::cell::RefCell;
 use core::fmt::Write;
 use core::str::from_utf8;
-use cortex_m::asm::delay;
 use cyw43::JoinOptions;
 use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
 use defmt::info;
 use defmt::*;
-use embassy_embedded_hal::shared_bus::I2cDeviceError;
 use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_executor::Spawner;
 use embassy_net::StackResources;
···
 use embassy_rp::clocks::RoscRng;
 use embassy_rp::flash::Async;
 use embassy_rp::gpio::Input;
-use embassy_rp::i2c::{Error, I2c};
+use embassy_rp::i2c::I2c;
 use embassy_rp::peripherals::{DMA_CH0, I2C0, PIO0, SPI0};
 use embassy_rp::pio::{InterruptHandler, Pio};
 use embassy_rp::rtc::{DateTime, DayOfWeek};
···
     let btn_c = Input::new(p.PIN_14, Pull::Down);
     let rtc_alarm = Input::new(p.PIN_8, Pull::Down);
 
+    //Setup i2c bus
+    let config = embassy_rp::i2c::Config::default();
+    let i2c = i2c::I2c::new_blocking(p.I2C0, p.PIN_5, p.PIN_4, config);
+    static I2C_BUS: StaticCell<I2c0Bus> = StaticCell::new();
+    let i2c_bus = NoopMutex::new(RefCell::new(i2c));
+    let i2c_bus = I2C_BUS.init(i2c_bus);
+
+    let i2c_dev = I2cDevice::new(i2c_bus);
+    let mut rtc_device = PCF85063::new(i2c_dev);
+
+    if btn_a.is_high() {
+        //Clears the alarm on start if A button is pressed (manual start)
+        _ = rtc_device.disable_all_alarms();
+        _ = rtc_device.clear_alarm_flag();
+    }
+
     let spi = Spi::new(
         p.SPI0,
         clk,
···
         seed,
     );
 
-    //rtc setup
-    // let mut rtc = embassy_rp::rtc::Rtc::new(p.RTC);
-
     spawner.must_spawn(net_task(runner));
     //Attempt to connect to wifi to get RTC time loop for 2 minutes
     let mut wifi_connection_attempts = 0;
···
         Timer::after(Duration::from_secs(1)).await;
         wifi_connection_attempts += 1;
     }
-
-    //Setup i2c bus
-    let config = embassy_rp::i2c::Config::default();
-    let i2c = i2c::I2c::new_blocking(p.I2C0, p.PIN_5, p.PIN_4, config);
-    static I2C_BUS: StaticCell<I2c0Bus> = StaticCell::new();
-    let i2c_bus = NoopMutex::new(RefCell::new(i2c));
-    let i2c_bus = I2C_BUS.init(i2c_bus);
-
-    let i2c_dev = I2cDevice::new(i2c_bus);
-    let mut rtc_device = PCF85063::new(i2c_dev);
 
     if connected_to_wifi {
         info!("waiting for DHCP...");
···
     let cycle = Duration::from_millis(100);
     let mut current_cycle = 0;
     let mut time_to_scan = true;
-    //15 minutes(ish) idk it's late and my math is so bad rn
-    let reset_cycle = 9_000;
+    //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();
 
     //RTC alarm stuff
-    // info!("going to sleep");
-    // Timer::after(Duration::from_millis(5_000)).await;
-    // //Set the rtc and sleep for 15 minutes
-    // //goes to sleep for 15 mins
-    // _ = rtc_device.clear_alarm_flag();
-    // _ = rtc_device.set_alarm_minutes(5);
-    // _ = rtc_device.control_alarm_minutes(Control::On);
-    // _ = rtc_device.control_alarm_interrupt(Control::On);
-    // power.set_low();
+    let mut go_to_sleep = false;
+    let mut reset_cycles_till_sleep = 0;
+    //Like 15ish mins??
+    let sleep_after_cycles = 4;
+
+    if rtc_alarm.is_high() {
+        //sleep happened
+        go_to_sleep = true;
+        info!("Alarm went off");
+        _ = rtc_device.disable_all_alarms();
+        _ = rtc_device.clear_alarm_flag();
+    } else {
+        info!("Alarm was clear")
+    }
 
     loop {
         //Change Image Button
         if btn_c.is_high() {
             info!("Button C pressed");
+            reset_cycles_till_sleep = 0;
             let current_image = CURRENT_IMAGE.load(core::sync::atomic::Ordering::Relaxed);
             let new_image = DisplayImage::from_u8(current_image).unwrap().next();
             CURRENT_IMAGE.store(new_image.as_u8(), core::sync::atomic::Ordering::Relaxed);
···
         if btn_a.is_high() {
             println!("{:?}", current_cycle);
             info!("Button A pressed");
+            reset_cycles_till_sleep = 0;
             user_led.toggle();
             Timer::after(Duration::from_millis(500)).await;
             continue;
···
 
         if btn_down.is_high() {
             info!("Button Down pressed");
+            reset_cycles_till_sleep = 0;
             SCREEN_TO_SHOW.lock(|screen| {
                 screen.replace(Screen::WifiList);
             });
···
 
         if btn_up.is_high() {
             info!("Button Up pressed");
+            reset_cycles_till_sleep = 0;
             SCREEN_TO_SHOW.lock(|screen| {
                 screen.replace(Screen::Badge);
             });
···
 
         if btn_b.is_high() {
             info!("Button B pressed");
+            reset_cycles_till_sleep = 0;
             SCREEN_TO_SHOW.lock(|screen| {
                 if *screen.borrow() == Screen::Badge {
                     //IF on badge screen and b pressed reset wifi count
···
 
         if time_to_scan {
             info!("Scanning for wifi networks");
+            reset_cycles_till_sleep += 1;
             time_to_scan = false;
             let mut scanner = control.scan(Default::default()).await;
             while let Some(bss) = scanner.next().await {
···
             current_cycle = 0;
             time_to_scan = true;
         }
+
+        if reset_cycles_till_sleep >= sleep_after_cycles {
+            info!("Going to sleep");
+            reset_cycles_till_sleep = 0;
+            go_to_sleep = true;
+        }
+
+        if go_to_sleep {
+            info!("going to sleep");
+            Timer::after(Duration::from_secs(25)).await;
+            //Set the rtc and sleep for 15 minutes
+            //goes to sleep for 15 mins
+            _ = rtc_device.disable_all_alarms();
+            _ = rtc_device.clear_alarm_flag();
+            _ = rtc_device.set_alarm_seconds(5);
+            _ = rtc_device.control_alarm_seconds(Control::On);
+            _ = rtc_device.control_alarm_interrupt(Control::On);
+            power.set_low();
+        }
+
         current_cycle += 1;
         Timer::after(cycle).await;
     }

src/pcf85063a/mod.rs

···
 #![allow(dead_code)]
+
+///None of this code is mine. It's https://crates.io/crates/pcf85063a
+/// I just needed a synchronous version so did a local clone and pulled the async and awaits
 pub mod alarm;
 pub mod datetime;
 
 use embedded_hal_1::i2c::I2c;
 
 /// All possible errors in this crate
-#[derive(Debug)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, defmt::Format)]
 pub enum Error<E> {
     /// I2C bus error
     I2C(E),
···
 
 /// Two possible choices, used for various enable/disable bit flags
 #[allow(non_camel_case_types)]
-#[derive(Copy, Clone, Debug)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Copy, Clone, Debug, defmt::Format)]
 pub enum Control {
     /// Enable some feature, eg. timer
     On,
···
 }
 
 /// PCF8563 driver
-#[derive(Debug, Default)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, Default, defmt::Format)]
 pub struct PCF85063<I2C> {
     /// The concrete I2C device implementation.
     i2c: I2C,
···
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, defmt::Format)]
 #[repr(u8)]
 pub enum OutputFrequency {
     Hz32768 = 0b000,