image loading

.cargo/config.toml

···
 runner = "probe-rs run --chip RP2040"
 
 [build]
-target = "thumbv6m-none-eabi"        # Cortex-M0 and Cortex-M0+
+target = "thumbv6m-none-eabi" # Cortex-M0 and Cortex-M0+
 
 [env]
 DEFMT_LOG = "debug"

.gitignore

···
 /target
-.DS_Store
+.DS_Store
+.env

Cargo.lock

···
  "smart-leds",
  "st7789",
  "static_cell",
+ "tinybmp",
  "trouble-host",
  "uc8151",
  "usbd-hid",
···
 checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
 dependencies = [
  "crunchy",
+]
+
+[[package]]
+name = "tinybmp"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "197cc000e382175ff15abd9c54c694ef80ef20cb07e7f956c71e3ea97fc8dc60"
+dependencies = [
+ "embedded-graphics",
 ]
 
 [[package]]

Cargo.toml

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

src/image_handler.rs

···
+use core::sync::atomic::{AtomicBool, AtomicU8};
+
+use embedded_graphics::prelude::Point;
+
+pub static CURRENT_IMAGE: AtomicU8 = AtomicU8::new(0);
+pub static CHANGE_IMAGE: AtomicBool = AtomicBool::new(true);
+
+static NUMBER_OF_IMAGES: u8 = 2;
+static FERRIS_IMG: &[u8; 15722] = include_bytes!("../images/ferris_w_a_knife.bmp");
+static REPO_IMG: &[u8; 11262] = include_bytes!("../images/repo.bmp");
+
+pub enum DisplayImage {
+    Ferris = 0,
+    Repo = 1,
+}
+
+pub fn get_current_image() -> DisplayImage {
+    DisplayImage::from_u8(CURRENT_IMAGE.load(core::sync::atomic::Ordering::Relaxed)).unwrap()
+}
+
+impl DisplayImage {
+    pub fn from_u8(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(Self::Ferris),
+            1 => Some(Self::Repo),
+            _ => None,
+        }
+    }
+
+    pub fn as_u8(&self) -> u8 {
+        match self {
+            Self::Ferris => 0,
+            Self::Repo => 1,
+        }
+    }
+
+    pub fn image(&self) -> &'static [u8] {
+        match self {
+            Self::Ferris => FERRIS_IMG,
+            Self::Repo => REPO_IMG,
+        }
+    }
+
+    pub fn next(&self) -> Self {
+        let image_count = self.as_u8();
+        let next_image = (image_count + 1) % NUMBER_OF_IMAGES;
+        DisplayImage::from_u8(next_image).unwrap()
+    }
+
+    pub fn previous(&self) -> Self {
+        let image_count = self.as_u8();
+        if image_count == 0 {
+            return DisplayImage::from_u8(NUMBER_OF_IMAGES - 1).unwrap();
+        }
+        let previous_image = (image_count - 1) % NUMBER_OF_IMAGES;
+        DisplayImage::from_u8(previous_image).unwrap()
+    }
+
+    pub fn image_location(&self) -> Point {
+        match self {
+            Self::Ferris => Point::new(150, 26),
+            Self::Repo => Point::new(190, 26),
+        }
+    }
+}

src/main.rs

···
 #![no_std]
 #![no_main]
 use core::sync::atomic::AtomicU32;
-
-use cyw43_driver::setup_cyw43;
 use defmt::info;
 use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
 use embassy_executor::Spawner;
···
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::mutex::Mutex;
 use embassy_time::{Delay, Duration, Timer};
-use embedded_graphics::primitives::PrimitiveStyleBuilder;
-use embedded_graphics::text::Text;
 use embedded_graphics::{
+    image::Image,
     mono_font::{ascii::*, MonoTextStyle},
     pixelcolor::BinaryColor,
     prelude::*,
···
 };
 use gpio::{Level, Output, Pull};
 use heapless::String;
+use image_handler::{get_current_image, DisplayImage, CHANGE_IMAGE, CURRENT_IMAGE};
 use static_cell::StaticCell;
+use tinybmp::Bmp;
 use uc8151::asynch::Uc8151;
 use uc8151::LUT;
 use uc8151::WIDTH;
 use {defmt_rtt as _, panic_probe as _};
+
 mod cyw43_driver;
+mod image_handler;
 
 type Spi0Bus = Mutex<NoopRawMutex, Spi<'static, SPI0, spi::Async>>;
+
 static WIFI_COUNT: AtomicU32 = AtomicU32::new(0);
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
-    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,
-    )
-    .await;
+    // 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,
+    // )
+    // .await;
 
     // let input = gpio::Input::new(p.PIN_29, gpio::Pull::Up);
 
···
     let reset = p.PIN_21;
     let power = p.PIN_10;
 
-    let btn_up = p.PIN_15;
-    let btn_down = p.PIN_11;
-    let btn_a = p.PIN_12;
-    let btn_b = p.PIN_13;
-    let btn_c = p.PIN_14;
-
     let reset = Output::new(reset, Level::Low);
     let _power = Output::new(power, Level::Low);
 
···
     let cs = Output::new(cs, Level::High);
     let busy = Input::new(busy, Pull::Up);
 
-    let mut _btn_up = Input::new(btn_up, Pull::Up);
-    let mut _btn_down = Input::new(btn_down, Pull::Up);
-    let mut _btn_a = Input::new(btn_a, Pull::Up);
-    let mut _btn_b = Input::new(btn_b, Pull::Up);
-    let mut _btn_c = Input::new(btn_c, Pull::Up);
+    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_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,
···
     let spi_bus = SPI_BUS.init(Mutex::new(spi));
 
     info!("led on!");
-    control.gpio_set(0, true).await;
+    // control.gpio_set(0, true).await;
     spawner.must_spawn(run_the_display(spi_bus, cs, dc, busy, reset));
+
+    //Input loop
+    loop {
+        //Change Image Button
+        if btn_c.is_high() {
+            info!("Button C pressed");
+            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);
+            CHANGE_IMAGE.store(true, core::sync::atomic::Ordering::Relaxed);
+            Timer::after(Duration::from_millis(500)).await;
+            continue;
+        }
+        Timer::after(Duration::from_millis(100)).await;
+    }
 }
 
 #[embassy_executor::task]
···
     let character_style = MonoTextStyle::new(&FONT_9X18_BOLD, BinaryColor::Off);
     let textbox_style = TextBoxStyleBuilder::new()
         .height_mode(HeightMode::FitToText)
-        .alignment(HorizontalAlignment::Center)
+        .alignment(HorizontalAlignment::Left)
         .paragraph_spacing(6)
         .build();
 
     // Bounding box for our text. Fill it with the opposite color so we can read the text.
-    let bounds = Rectangle::new(Point::new(0, 40), Size::new(WIDTH - 157, 0));
-    bounds
+    let name_and_detail_bounds = Rectangle::new(Point::new(0, 40), Size::new(WIDTH - 75, 0));
+    name_and_detail_bounds
         .into_styled(PrimitiveStyle::with_fill(BinaryColor::On))
         .draw(&mut display)
         .unwrap();
 
     // Create the text box and apply styling options.
-    let text = "Written In\nRust!!";
-    let text_box = TextBox::with_textbox_style(text, bounds, character_style, textbox_style);
+
+    let text = "Bailey Townsend\nSoftware Dev";
+    // \nWritten in rust\nRunning on a pico w";
+    let name_and_detail_box =
+        TextBox::with_textbox_style(text, name_and_detail_bounds, character_style, textbox_style);
 
     // Draw the text box.
-    text_box.draw(&mut display).unwrap();
+    name_and_detail_box.draw(&mut display).unwrap();
 
     let _ = display.update().await;
 
···
 
     loop {
         let count = WIFI_COUNT.load(core::sync::atomic::Ordering::Relaxed);
-        let _ = core::fmt::write(&mut text, format_args!("Count: {}", count));
-        let count_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
-        count_bounds
-            .into_styled(
-                PrimitiveStyleBuilder::default()
-                    .stroke_color(BinaryColor::Off)
-                    .fill_color(BinaryColor::On)
-                    .stroke_width(1)
-                    .build(),
-            )
-            .draw(&mut display)
-            .unwrap();
+        // let _ = core::fmt::write(&mut text, format_args!("Count: {}", count));
+        // let count_bounds = Rectangle::new(Point::new(0, 0), Size::new(WIDTH, 24));
+        // count_bounds
+        //     .into_styled(
+        //         PrimitiveStyleBuilder::default()
+        //             .stroke_color(BinaryColor::Off)
+        //             .fill_color(BinaryColor::On)
+        //             .stroke_width(1)
+        //             .build(),
+        //     )
+        //     .draw(&mut display)
+        //     .unwrap();
 
-        Text::new(text.as_str(), Point::new(8, 16), character_style)
-            .draw(&mut display)
-            .unwrap();
+        // Text::new(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;
-        match result {
-            Ok(_) => {}
-            Err(_) => {
-                info!("Error updating display");
-            }
-        }
-        text.clear();
+        // // // Draw the text box.
+        // let result = display
+        //     .partial_update(count_bounds.try_into().unwrap())
+        //     .await;
+        // match result {
+        //     Ok(_) => {}
+        //     Err(_) => {
+        //         info!("Error updating display");
+        //     }
+        // }
+        // text.clear();
         // let _ = display.clear(Rgb565::WHITE.into());
         // let _ = display.update().await;
         WIFI_COUNT.store(count + 1, core::sync::atomic::Ordering::Relaxed);
 
-        Timer::after(delay).await;
+        if CHANGE_IMAGE.load(core::sync::atomic::Ordering::Relaxed) {
+            let current_image = get_current_image();
+            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 clear_bounds = Rectangle::new(
+                current_image.previous().image_location(),
+                Size::new(157, 91),
+            );
+            clear_bounds
+                .into_styled(PrimitiveStyle::with_fill(BinaryColor::On))
+                .draw(&mut display)
+                .unwrap();
+
+            let _ = image.draw(&mut display);
+            let _ = display.update().await;
+            CHANGE_IMAGE.store(false, core::sync::atomic::Ordering::Relaxed);
+        }
+
+        Timer::after(Duration::from_millis(500)).await;
     }
 }