We got real time temps homie

Cargo.lock

···
  "reqwless",
  "serde",
  "serde-json-core",
+ "shtcx",
  "smart-leds",
  "st7789",
  "static_cell",
···
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f179d4e11094a893b82fff208f74d448a7512f99f5a0acbd5c679b705f83ed9"
+
+[[package]]
+name = "shtcx"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c25d66e6c78c6e19160a5b528cebe6f54d5737f091a2b90b08dbd7e63a9269f"
+dependencies = [
+ "embedded-hal 1.0.0",
+]
 
 [[package]]
 name = "siphasher"

Cargo.toml

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

src/badge_display/mod.rs

···
     cell::RefCell,
     sync::atomic::{AtomicBool, AtomicU32, AtomicU8},
 };
-use cortex_m::interrupt::CriticalSection;
 use defmt::*;
 use display_image::get_current_image;
 use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
···
 pub static CURRENT_IMAGE: AtomicU8 = AtomicU8::new(0);
 pub static CHANGE_IMAGE: AtomicBool = AtomicBool::new(true);
 pub static WIFI_COUNT: AtomicU32 = AtomicU32::new(0);
-
 pub static RTC_TIME_STRING: blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<String<8>>> =
     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);
···
         //Runs every 30 cycles/15 seconds and first run
         if cycles_since_last_clear % 30 == 0 || first_run {
             let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
-            let count_text: String<16> = easy_format::<16>(format_args!("Count: {}", count));
-            let count_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
-            count_bounds
+            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_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
+            top_bounds
                 .into_styled(
                     PrimitiveStyleBuilder::default()
                         .stroke_color(BinaryColor::Off)
···
                 .draw(&mut display)
                 .unwrap();
 
-            Text::new(count_text.as_str(), Point::new(8, 16), character_style)
+            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(count_bounds.try_into().unwrap())
-                .await;
+            // Draw the text box.
+            let result = display.partial_update(top_bounds.try_into().unwrap()).await;
             match result {
                 Ok(_) => {}
                 Err(_) => {
                     info!("Error updating display");
                 }
             }
-            // let _ = display.clear(Rgb565::WHITE.into());
-            // let _ = display.update().await;
+
             WIFI_COUNT.store(count + 1, core::sync::atomic::Ordering::Relaxed);
         }
 
···
             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 image_bounds = Size::new(160, 140);
             let clear_rectangle = Rectangle::new(
                 current_image.previous().image_location(),
                 Size::new(157, 101),
···
 
             let _ = image.draw(&mut display);
             //TODO need to look up the reginal area display
-            //             let update_region = UpdateRegion::new(192, 32, 160, 144).unwrap();
-            // let result = display.partial_update(update_region).await;
             let _ = display.update().await;
             CHANGE_IMAGE.store(false, core::sync::atomic::Ordering::Relaxed);
         }

src/main.rs

···
 use embassy_rp::spi::{self};
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::mutex::Mutex;
-use embassy_time::{Delay, Duration, Timer};
-use embedded_graphics::{
-    image::Image,
-    mono_font::{ascii::*, MonoTextStyle},
-    pixelcolor::BinaryColor,
-    prelude::*,
-    primitives::{PrimitiveStyle, Rectangle},
-};
-use embedded_text::{
-    alignment::HorizontalAlignment,
-    style::{HeightMode, TextBoxStyleBuilder},
-    TextBox,
-};
+use embassy_time::{Duration, Timer};
 use gpio::{Level, Output, Pull};
 use helpers::easy_format;
 use static_cell::StaticCell;
+use temp_sensor::run_the_temp_sensor;
 use {defmt_rtt as _, panic_probe as _};
 
 mod badge_display;
 mod cyw43_driver;
 mod env;
 mod helpers;
+mod temp_sensor;
 
 type Spi0Bus = Mutex<NoopRawMutex, Spi<'static, SPI0, spi::Async>>;
 
···
     let _btn_b = Input::new(p.PIN_13, Pull::Down);
     let btn_c = Input::new(p.PIN_14, Pull::Down);
 
-    // let mut btn_c: Debouncer<'_> = Debouncer::new(Input::new(btn_c, Pull::Up), Duration::from_millis(20));
-
     let spi = Spi::new(
         p.SPI0,
         clk,
···
         p.DMA_CH2,
         spi::Config::default(),
     );
-    // let spi_bus: Mutex<NoopRawMutex, _> = Mutex::new(spi);
+
+    //SPI Bus setup to run the e-ink display
     static SPI_BUS: StaticCell<Spi0Bus> = StaticCell::new();
     let spi_bus = SPI_BUS.init(Mutex::new(spi));
 
     info!("led on!");
     // control.gpio_set(0, true).await;
+    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));
 
     //rtc setup
···
             month: 1,
             day: 1,
             day_of_week: DayOfWeek::Saturday,
-            hour: 0,
-            minute: 0,
+            hour: 18,
+            minute: 31,
             second: 0,
         };
         rtc.set_datetime(now).unwrap();

src/temp_sensor.rs

···
+use bt_hci::cmd::info;
+use defmt::*;
+use embassy_rp::i2c::{I2c, SclPin, SdaPin};
+use embassy_rp::peripherals::I2C0;
+use embassy_rp::{i2c, Peripheral};
+use embassy_time::Timer;
+use shtcx::{self, PowerMode};
+
+use crate::badge_display::{HUMIDITY, TEMP}; // Import the necessary items from shtcx
+
+#[embassy_executor::task]
+pub async fn run_the_temp_sensor(
+    i2c0: I2C0,
+    scl: impl Peripheral<P = impl SclPin<I2C0>> + 'static,
+    sda: impl Peripheral<P = impl SdaPin<I2C0>> + 'static,
+) {
+    let i2c = I2c::new_blocking(i2c0, scl, sda, i2c::Config::default());
+
+    let mut sht = shtcx::shtc3(i2c);
+    let mut sht_delay = embassy_time::Delay; // Create a delay instance
+
+    loop {
+        let combined = sht.measure(PowerMode::NormalMode, &mut sht_delay).unwrap();
+        let celsius = combined.temperature.as_degrees_celsius();
+        let fahrenheit = (celsius * 9.0 / 5.0) + 32.0;
+        info!(
+            "Temperature: {}°F, Humidity: {}%",
+            fahrenheit,
+            combined.humidity.as_percent()
+        );
+        TEMP.store(fahrenheit as u8, core::sync::atomic::Ordering::Relaxed);
+        HUMIDITY.store(
+            combined.humidity.as_percent() as u8,
+            core::sync::atomic::Ordering::Relaxed,
+        );
+        Timer::after_secs(120).await;
+    }
+}