Working partial updates

Cargo.toml

···
 debug = 2
 
 [profile.dev]
+debug = 1
 lto = true
 opt-level = "z"
 

src/control_driver.rs

···
 use cyw43_pio::PioSpi;
 use defmt::unwrap;
 use embassy_executor::Spawner;
+use embassy_net_wiznet::Device;
 use embassy_rp::bind_interrupts;
 use embassy_rp::gpio::{Level, Output};
 use embassy_rp::peripherals::{DMA_CH0, PIO0};
···
 });
 
 #[embassy_executor::task]
-async fn wifi_task(
+async fn cyw43_task(
     runner: cyw43::Runner<'static, Output<'static>, PioSpi<'static, PIO0, 0, DMA_CH0>>,
 ) -> ! {
     runner.run().await
 }
 
-pub async fn setup_control<'a>(
+pub async fn setup_cyw43<'a>(
     pio0: PIO0,
     p_23: PIN_23,
     p_24: PIN_24,
···
     p_29: PIN_29,
     dma_ch0: DMA_CH0,
     spawner: Spawner,
-) -> Control<'a> {
-    let fw = include_bytes!("../cyw43-firmware/43439A0.bin");
-    let clm = include_bytes!("../cyw43-firmware/43439A0_clm.bin");
+) -> (Device<'a>, Control<'a>) {
+    // let fw = include_bytes!("../cyw43-firmware/43439A0.bin");
+    // let clm = include_bytes!("../cyw43-firmware/43439A0_clm.bin");
+    // let btfw = include_bytes!("../cyw43-firmware/43439A0_btfw.bin");
 
     // To make flashing faster for development, you may want to flash the firmwares independently
     // at hardcoded addresses, instead of baking them into the program with `include_bytes!`:
     //     probe-rs download 43439A0.bin --binary-format bin --chip RP2040 --base-address 0x10100000
     //     probe-rs download 43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x10140000
-    // let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
-    // let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 230321) };
+    //     probe-rs download 43439A0_btfw.bin --binary-format bin --chip RP2040 --base-address 0x10141400
+    let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 224190) };
+    let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
+    let btfw = unsafe { core::slice::from_raw_parts(0x10141400 as *const u8, 6164) };
 
     let pwr = Output::new(p_23, Level::Low);
     let cs = Output::new(p_25, Level::High);
···
 
     static STATE: StaticCell<cyw43::State> = StaticCell::new();
     let state = STATE.init(cyw43::State::new());
-    let (_net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw).await;
-    unwrap!(spawner.spawn(wifi_task(runner)));
+    let (net_device, _bt_device, mut control, runner) =
+        cyw43::new_with_bluetooth(state, pwr, spi, fw, btfw).await;
+    unwrap!(spawner.spawn(cyw43_task(runner)));
 
     control.init(clm).await;
     control
         .set_power_management(cyw43::PowerManagementMode::PowerSave)
         .await;
-    control
+    (net_device, control)
 }

src/main.rs

···
 
 #![no_std]
 #![no_main]
-use control_driver::setup_control;
+use control_driver::setup_cyw43;
+use defmt::info;
 use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
 use embassy_executor::Spawner;
 use embassy_rp::gpio;
···
 use embassy_rp::spi::{self};
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
 use embassy_sync::mutex::Mutex;
-use embassy_time::Delay;
+use embassy_time::{Delay, Duration, Timer};
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::primitives::PrimitiveStyleBuilder;
+use embedded_graphics::text::Text;
 use embedded_graphics::{
     mono_font::{ascii::*, MonoTextStyle},
     pixelcolor::BinaryColor,
···
     TextBox,
 };
 use gpio::{Level, Output, Pull};
+use heapless::String;
 use uc8151::asynch::Uc8151;
-use uc8151::LUT;
 use uc8151::WIDTH;
+use uc8151::{UpdateRegion, LUT};
 use {defmt_rtt as _, panic_probe as _};
 mod control_driver;
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
-    let mut control = setup_control(
+    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 spi_bus: Mutex<NoopRawMutex, _> = Mutex::new(spi);
     let spi_dev = SpiDevice::new(&spi_bus, cs);
     let mut display = Uc8151::new(spi_dev, dc, busy, reset, Delay);
+
     display.reset().await;
 
     // Initialise display. Using the default LUT speed setting
-    let _ = display.setup(LUT::Internal).await;
+    let _ = display.setup(LUT::Fast).await;
 
     // Note we're setting the Text color to `Off`. The driver is set up to treat Off as Black so that BMPs work as expected.
     let character_style = MonoTextStyle::new(&FONT_9X18_BOLD, BinaryColor::Off);
···
         .build();
 
     // Bounding box for our text. Fill it with the opposite color so we can read the text.
-    let bounds = Rectangle::new(Point::new(10, 10), Size::new(WIDTH - 157, 0));
+    let bounds = Rectangle::new(Point::new(0, 40), Size::new(WIDTH - 157, 0));
     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 = "Written In\nRust!!";
     let text_box = TextBox::with_textbox_style(text, bounds, character_style, textbox_style);
 
     // Draw the text box.
     text_box.draw(&mut display).unwrap();
+
     let _ = display.update().await;
-    control.gpio_set(0, true).await;
+
+    let delay: Duration = Duration::from_secs(1);
+    let mut count = 0;
+    let mut text: String<16> = String::<16>::new();
+
+    loop {
+        info!("led on!");
+        control.gpio_set(0, true).await;
+        Timer::after(delay).await;
+
+        info!("led off!");
+        control.gpio_set(0, false).await;
+
+        Timer::after(delay).await;
 
-    // loop {
-    //     info!("led on!");
-    //     control.gpio_set(0, true).await;
-    //     Timer::after(delay).await;
+        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();
 
-    //     info!("led off!");
-    //     control.gpio_set(0, false).await;
+        Text::new(text.as_str(), Point::new(8, 16), character_style)
+            .draw(&mut display)
+            .unwrap();
 
-    //     Timer::after(delay).await;
-    // }
+        // // 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;
+        count += 1;
+        // Timer::after(Duration::from_secs(10)).await;
+    }
 }