increase clock speed of display

Cargo.lock

@@ -124,7 +124,7 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
 dependencies = [
- "rustc_version 0.2.3",
+ "rustc_version",
 ]
 
 [[package]]
@@ -225,7 +225,7 @@ dependencies = [
  "embedded-io",
  "embedded-io-async",
  "futures-intrusive",
- "heapless 0.8.0",
+ "heapless",
  "uuid",
 ]
 
@@ -409,7 +409,7 @@ dependencies = [
  "embedded-hal 1.0.0",
  "embedded-io-async",
  "futures",
- "heapless 0.8.0",
+ "heapless",
  "num_enum 0.5.11",
 ]
 
@@ -788,7 +788,7 @@ dependencies = [
  "embedded-io-async",
  "futures-sink",
  "futures-util",
- "heapless 0.8.0",
+ "heapless",
 ]
 
 [[package]]
@@ -803,7 +803,7 @@ dependencies = [
  "embedded-io-async",
  "futures-core",
  "futures-sink",
- "heapless 0.8.0",
+ "heapless",
 ]
 
 [[package]]
@@ -856,7 +856,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "80e2ee86063bd028a420a5fb5898c18c87a8898026da1d4c852af2c443d0a454"
 dependencies = [
  "embassy-executor-timer-queue",
- "heapless 0.8.0",
+ "heapless",
 ]
 
 [[package]]
@@ -870,7 +870,7 @@ dependencies = [
  "embassy-sync 0.7.2",
  "embassy-usb-driver 0.2.0",
  "embedded-io-async",
- "heapless 0.8.0",
+ "heapless",
  "ssmarshal",
  "usbd-hid",
 ]
@@ -1032,7 +1032,7 @@ dependencies = [
  "defmt 0.3.100",
  "embedded-hal 1.0.0",
  "embedded-io",
- "heapless 0.8.0",
+ "heapless",
 ]
 
 [[package]]
@@ -1312,15 +1312,6 @@ dependencies = [
  "crunchy",
 ]
 
-[[package]]
-name = "hash32"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -1351,26 +1342,13 @@ version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 
-[[package]]
-name = "heapless"
-version = "0.7.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
-dependencies = [
- "atomic-polyfill",
- "hash32 0.2.1",
- "rustc_version 0.4.1",
- "spin 0.9.8",
- "stable_deref_trait",
-]
-
 [[package]]
 name = "heapless"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad"
 dependencies = [
- "hash32 0.3.1",
+ "hash32",
  "serde",
  "stable_deref_trait",
 ]
@@ -1524,14 +1502,14 @@ dependencies = [
  "embedded-sdmmc",
  "embedded-text",
  "goblin",
- "heapless 0.8.0",
+ "heapless",
  "kolibri-embedded-gui",
  "num_enum 0.7.4",
  "once_cell",
  "panic-probe",
  "portable-atomic",
  "rand",
- "spin 0.10.0",
+ "spin",
  "st7365p-lcd",
  "static_cell",
  "strum",
@@ -1548,7 +1526,7 @@ dependencies = [
  "embedded-graphics",
  "embedded-iconoir",
  "foldhash",
- "heapless 0.8.0",
+ "heapless",
 ]
 
 [[package]]
@@ -2164,16 +2142,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "semver 0.9.0",
+ "semver",
-]
-
-[[package]]
-name = "rustc_version"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
-dependencies = [
- "semver 1.0.27",
 ]
 
 [[package]]
@@ -2231,12 +2200,6 @@ dependencies = [
  "semver-parser",
 ]
 
-[[package]]
-name = "semver"
-version = "1.0.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
-
 [[package]]
 name = "semver-parser"
 version = "0.7.0"
@@ -2342,15 +2305,6 @@ dependencies = [
  "rand",
 ]
 
-[[package]]
-name = "spin"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
-dependencies = [
- "lock_api",
-]
-
 [[package]]
 name = "spin"
 version = "0.10.0"
@@ -2379,7 +2333,7 @@ dependencies = [
  "embedded-graphics-core",
  "embedded-hal 1.0.0",
  "embedded-hal-async",
- "heapless 0.8.0",
+ "heapless",
  "nb 1.1.0",
 ]
 
@@ -2609,11 +2563,10 @@ dependencies = [
 [[package]]
 name = "tinygif"
 version = "0.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/LegitCamper/tinygif#083c0efbdbeb21835de30425e234247340f6e370"
-checksum = "09f1406b710986188de8d393c810213d4bbf940e327d90d52cff9930d007a248"
 dependencies = [
  "embedded-graphics",
- "heapless 0.7.17",
+ "heapless",
 ]
 
 [[package]]
@@ -2637,7 +2590,7 @@ dependencies = [
  "embassy-time 0.4.0",
  "embedded-io",
  "futures",
- "heapless 0.8.0",
+ "heapless",
  "rand_core 0.6.4",
  "static_cell",
  "trouble-host-macros",
@@ -2688,7 +2641,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98816b1accafbb09085168b90f27e93d790b4bfa19d883466b5e53315b5f06a6"
 dependencies = [
- "heapless 0.8.0",
+ "heapless",
  "portable-atomic",
 ]
 

abi/src/lib.rs

@@ -46,7 +46,7 @@ pub fn get_key() -> KeyEvent {
 
 pub mod display {
     use abi_sys::CPixel;
-    // use alloc::{vec, vec::Vec};
+    use alloc::{vec, vec::Vec};
     use embedded_graphics::{
         Pixel,
         geometry::{Dimensions, Point},
@@ -54,7 +54,7 @@ pub mod display {
         prelude::{DrawTarget, Size},
         primitives::Rectangle,
     };
-    // use once_cell::unsync::Lazy;
+    use once_cell::unsync::Lazy;
 
     pub const SCREEN_WIDTH: usize = 320;
     pub const SCREEN_HEIGHT: usize = 320;

abi_sys/src/lib.rs

@@ -46,7 +46,7 @@ pub struct CLayout {
 #[cfg(feature = "alloc")]
 impl Into<Layout> for CLayout {
     fn into(self) -> Layout {
-        Layout::from_size_align(self.size, self.alignment).unwrap()
+        unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) }
     }
 }
 

kernel/src/abi.rs

@@ -3,7 +3,7 @@ use abi_sys::{
     PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
 };
 use alloc::{string::ToString, vec::Vec};
-use core::{alloc::GlobalAlloc, ops::DerefMut, sync::atomic::Ordering};
+use core::{alloc::GlobalAlloc, sync::atomic::Ordering};
 use embassy_rp::clocks::{RoscRng, clk_sys_freq};
 use embassy_time::Instant;
 use embedded_graphics::draw_target::DrawTarget;
@@ -11,7 +11,8 @@ use embedded_sdmmc::{DirEntry, LfnBuffer};
 use heapless::spsc::Queue;
 
 use crate::{
-    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
+    display::FRAMEBUFFER,
+    framebuffer::FB_PAUSED,
     storage::{Dir, File, SDCARD},
 };
 
@@ -79,19 +80,9 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
 
     let iter = cpixels.iter().copied().map(|c: CPixel| c.into());
 
-    let fb = if cfg!(feature = "pimoroni2w") {
+    FB_PAUSED.store(true, Ordering::Release);
-        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
+    unsafe { FRAMEBUFFER.draw_iter(iter).unwrap() }
-            unsafe { FRAMEBUFFER2.deref_mut() }
+    FB_PAUSED.store(false, Ordering::Release);
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        }
-    } else {
-        unsafe { &mut FRAMEBUFFER }
-    };
-
-    fb.draw_iter(iter).unwrap();
-
-    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
 }
 
 pub static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();

kernel/src/display.rs

@@ -1,10 +1,6 @@
-use crate::framebuffer::{self, AtomicFrameBuffer};
+use crate::framebuffer::{self, AtomicFrameBuffer, FB_PAUSED};
 use alloc::vec;
-use core::alloc::GlobalAlloc;
+use core::sync::atomic::{AtomicBool, Ordering};
-use core::alloc::Layout;
-#[cfg(feature = "pimoroni2w")]
-use core::sync::atomic::AtomicBool;
-use core::sync::atomic::Ordering;
 use embassy_rp::{
     Peri,
     gpio::{Level, Output},
@@ -26,34 +22,11 @@ type DISPLAY = ST7365P<
 pub const SCREEN_WIDTH: usize = 320;
 pub const SCREEN_HEIGHT: usize = 320;
 
-// used to switch which fb is being used for read/write
-#[cfg(feature = "pimoroni2w")]
-pub static WRITE_FRAMEBUFFER2: AtomicBool = AtomicBool::new(false);
-
-// the default screen buffer - the only one on boards without extra ram or psram
 pub static mut FRAMEBUFFER: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
     static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
     AtomicFrameBuffer::new(unsafe { &mut BUF })
 });
 
-#[cfg(feature = "pimoroni2w")]
-pub static mut FRAMEBUFFER2: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
-    use embedded_graphics::{
-        pixelcolor::Rgb565,
-        prelude::{DrawTarget, RgbColor},
-    };
-
-    let buf = unsafe {
-        let slab =
-            crate::heap::HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap()) as *mut u16;
-        core::slice::from_raw_parts_mut(slab, framebuffer::SIZE)
-    };
-    let mut fb = AtomicFrameBuffer::new(buf);
-    fb.set_all_tiles(false);
-    fb.clear(Rgb565::BLACK).unwrap();
-    fb
-});
-
 pub async fn init_display(
     spi: Spi<'static, SPI1, Async>,
     cs: Peri<'static, PIN_13>,
@@ -80,18 +53,11 @@ pub async fn init_display(
 #[embassy_executor::task]
 pub async fn display_handler(mut display: DISPLAY) {
     loop {
-        let fb = if cfg!(feature = "pimoroni2w") {
+        if !FB_PAUSED.load(Ordering::Acquire) {
-            if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
+            unsafe { FRAMEBUFFER.safe_draw(&mut display).await.unwrap() };
-                unsafe { &mut FRAMEBUFFER }
-            } else {
-                unsafe { &mut FRAMEBUFFER2 }
         }
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        };
-        fb.safe_draw(&mut display).await.unwrap();
 
         // small yield to allow other tasks to run
-        Timer::after_nanos(100).await;
+        Timer::after_nanos(500).await;
     }
 }

kernel/src/framebuffer.rs

@@ -23,29 +23,23 @@ type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
 
 pub const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
 
+pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
+
+static mut DIRTY_TILES: LazyLock<heapless::Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
+    let mut tiles = heapless::Vec::new();
+    for _ in 0..TILE_COUNT {
+        tiles.push(AtomicBool::new(true)).unwrap();
+    }
+    tiles
+});
+
 #[allow(dead_code)]
-pub struct AtomicFrameBuffer<'a> {
+pub struct AtomicFrameBuffer<'a>(&'a mut [u16]);
-    fb: &'a mut [u16],
-    dirty_tiles: heapless::Vec<AtomicBool, TILE_COUNT>,
-}
 
 impl<'a> AtomicFrameBuffer<'a> {
     pub fn new(buffer: &'a mut [u16]) -> Self {
         assert!(buffer.len() == SIZE);
-        let mut dirty_tiles = heapless::Vec::new();
+        Self(buffer)
-        for _ in 0..TILE_COUNT {
-            dirty_tiles.push(AtomicBool::new(true)).unwrap()
-        }
-        Self {
-            fb: buffer,
-            dirty_tiles,
-        }
-    }
-
-    pub fn set_all_tiles(&mut self, set: bool) {
-        for t in self.dirty_tiles.iter_mut() {
-            t.store(set, Ordering::Release);
-        }
     }
 
     fn mark_tiles_dirty(&mut self, rect: Rectangle) {
@@ -58,7 +52,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for ty in start_ty..=end_ty {
             for tx in start_tx..=end_tx {
                 let tile_idx = ty * tiles_x + tx;
-                self.dirty_tiles[tile_idx].store(true, Ordering::Release);
+                unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Release) };
             }
         }
     }
@@ -84,7 +78,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         for y in sy..=ey {
             for x in sx..=ex {
                 if let Some(color) = color_iter.next() {
-                    self.fb[(y as usize * SCREEN_WIDTH) + x as usize] = color;
+                    self.0[(y as usize * SCREEN_WIDTH) + x as usize] = color;
                 } else {
                     return Err(()); // Not enough data
                 }
@@ -107,7 +101,7 @@ impl<'a> AtomicFrameBuffer<'a> {
             let mut tx = 0;
             while tx < tiles_x {
                 let idx = ty * tiles_x + tx;
-                if !self.dirty_tiles[idx].load(Ordering::Acquire) {
+                if !unsafe { DIRTY_TILES.get()[idx].load(Ordering::Acquire) } {
                     tx += 1;
                     continue;
                 }
@@ -119,7 +113,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                 // Grow horizontally, but keep under MAX_TILES_PER_METATILE
                 while tx + width_tiles < tiles_x
                     && unsafe {
-                        self.dirty_tiles[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
+                        DIRTY_TILES.get()[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
                     }
                     && (width_tiles + height_tiles) <= MAX_META_TILES
                 {
@@ -130,7 +124,8 @@ impl<'a> AtomicFrameBuffer<'a> {
 
                 for x_off in 0..width_tiles {
                     unsafe {
-                        self.dirty_tiles[ty * tiles_x + tx + x_off].store(false, Ordering::Release);
+                        DIRTY_TILES.get()[ty * tiles_x + tx + x_off]
+                            .store(false, Ordering::Release);
                     };
                 }
 
@@ -170,12 +165,12 @@ impl<'a> AtomicFrameBuffer<'a> {
                 0,
                 self.size().width as u16 - 1,
                 self.size().height as u16 - 1,
-                &self.fb[..],
+                &self.0[..],
             )
             .await?;
 
         unsafe {
-            for tile in self.dirty_tiles.iter() {
+            for tile in DIRTY_TILES.get_mut().iter() {
                 tile.store(false, Ordering::Release);
             }
         };
@@ -196,10 +191,11 @@ impl<'a> AtomicFrameBuffer<'a> {
         let tiles_x = SCREEN_WIDTH / TILE_SIZE;
         let _tiles_y = SCREEN_HEIGHT / TILE_SIZE;
 
+        let tiles = unsafe { DIRTY_TILES.get_mut() };
         let mut pixel_buffer: heapless::Vec<u16, { TILE_SIZE * TILE_SIZE }> = heapless::Vec::new();
 
         for tile_idx in 0..TILE_COUNT {
-            if self.dirty_tiles[tile_idx].swap(false, Ordering::AcqRel) {
+            if tiles[tile_idx].swap(false, Ordering::AcqRel) {
                 let tx = tile_idx % tiles_x;
                 let ty = tile_idx / tiles_x;
 
@@ -214,9 +210,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                 for y in y_start..y_end {
                     let start = y * SCREEN_WIDTH + x_start;
                     let end = y * SCREEN_WIDTH + x_end;
-                    pixel_buffer
+                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
-                        .extend_from_slice(&self.fb[start..end])
-                        .unwrap();
                 }
 
                 display
@@ -246,7 +240,7 @@ impl<'a> AtomicFrameBuffer<'a> {
         RST: OutputPin,
         DELAY: DelayNs,
     {
-        if unsafe { self.dirty_tiles.iter().any(|p| p.load(Ordering::Acquire)) } {
+        if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
             let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
             let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
 
@@ -270,9 +264,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                     let end = start + rect_width;
 
                     // Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
-                    pixel_buffer
+                    pixel_buffer.extend_from_slice(&self.0[start..end]).unwrap();
-                        .extend_from_slice(&self.fb[start..end])
-                        .unwrap();
                 }
 
                 display
@@ -294,7 +286,7 @@ impl<'a> AtomicFrameBuffer<'a> {
                 for ty in start_ty..=end_ty {
                     for tx in start_tx..=end_tx {
                         let tile_idx = ty * tiles_x + tx;
-                        self.dirty_tiles[tile_idx].store(false, Ordering::Release);
+                        unsafe { DIRTY_TILES.get_mut()[tile_idx].store(false, Ordering::Release) };
                     }
                 }
             }
@@ -323,8 +315,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                 if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
                     let idx = (y as usize) * SCREEN_WIDTH + (x as usize);
                     let raw_color = RawU16::from(color).into_inner();
-                    if self.fb[idx] != raw_color {
+                    if self.0[idx] != raw_color {
-                        self.fb[idx] = raw_color;
+                        self.0[idx] = raw_color;
                         changed = true;
                     }
 
@@ -373,8 +365,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                         if let Some(color) = colors.next() {
                             let idx = (p.y as usize * SCREEN_WIDTH) + (p.x as usize);
                             let raw_color = RawU16::from(color).into_inner();
-                            if self.fb[idx] != raw_color {
+                            if self.0[idx] != raw_color {
-                                self.fb[idx] = raw_color;
+                                self.0[idx] = raw_color;
                                 changed = true;
                             }
                         } else {
@@ -412,7 +404,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
                 .take((self.size().width * self.size().height) as usize),
         )?;
 
-        for tile in self.dirty_tiles.iter() {
+        for tile in unsafe { DIRTY_TILES.get_mut() }.iter() {
             tile.store(true, Ordering::Release);
         }
 

kernel/src/main.rs

@@ -246,7 +246,7 @@ async fn setup_mcu(mcu: Mcu) {
 
 async fn setup_display(display: Display, spawner: Spawner) {
     let mut config = spi::Config::default();
-    config.frequency = 16_000_000;
+    config.frequency = 64_000_000;
     let spi = Spi::new(
         display.spi,
         display.clk,
@@ -323,11 +323,6 @@ async fn kernel_task(
     spawner
         .spawn(watchdog_task(Watchdog::new(watchdog)))
         .unwrap();
-
-    // setup_psram(psram).await;
-    #[cfg(feature = "pimoroni2w")]
-    setup_qmi_psram().await;
-
     setup_mcu(mcu).await;
     setup_display(display, spawner).await;
     setup_sd(sd).await;
@@ -335,6 +330,10 @@ async fn kernel_task(
     let _usb = embassy_rp_usb::Driver::new(usb, Irqs);
     // spawner.spawn(usb_handler(usb)).unwrap();
 
+    // setup_psram(psram).await;
+    #[cfg(feature = "pimoroni2w")]
+    setup_qmi_psram().await;
+
     loop {
         let ui_enabled = ENABLE_UI.load(Ordering::Relaxed);
         if ui_enabled {

kernel/src/ui.rs

@@ -1,13 +1,10 @@
 use crate::{
-    BINARY_CH,
+    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
-    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
+    peripherals::keyboard, storage::FileName,
-    elf::load_binary,
-    peripherals::keyboard,
-    storage::FileName,
 };
 use abi_sys::keyboard::{KeyCode, KeyState};
 use alloc::{str::FromStr, string::String, vec::Vec};
-use core::{ops::DerefMut, sync::atomic::Ordering};
+use core::sync::atomic::Ordering;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
 use embedded_graphics::{
     Drawable,
@@ -86,15 +83,7 @@ async fn draw_selection() {
     const NO_BINS: &str = "No Programs found on SD Card. Ensure programs end with '.bin', and are located in the root directory";
     let no_bins = String::from_str(NO_BINS).unwrap();
 
-    let mut fb = if cfg!(feature = "pimoroni2w") {
+    FB_PAUSED.store(true, Ordering::Release); // ensure all elements show up at once
-        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
-            unsafe { FRAMEBUFFER2.deref_mut() }
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        }
-    } else {
-        unsafe { &mut FRAMEBUFFER }
-    };
 
     if file_names.is_empty() {
         TextBox::new(
@@ -105,7 +94,7 @@ async fn draw_selection() {
             ),
             text_style,
         )
-        .draw(fb.deref_mut())
+        .draw(unsafe { &mut *FRAMEBUFFER })
         .unwrap();
     } else {
         let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
@@ -130,17 +119,16 @@ async fn draw_selection() {
             .bounding_box();
         Rectangle::new(selected_bounds.top_left, selected_bounds.size)
             .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
-            .draw(fb.deref_mut())
+            .draw(unsafe { &mut *FRAMEBUFFER })
             .unwrap();
 
         guard.last_bounds = Some(layout.bounds());
 
-        layout.draw(fb.deref_mut()).unwrap();
+        layout.draw(unsafe { &mut *FRAMEBUFFER }).unwrap();
     }
 
     guard.changed = false;
-
+    FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
-    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
 }
 
 #[derive(Clone)]

user-apps/gif/Cargo.toml

@@ -6,4 +6,4 @@ edition = "2024"
 [dependencies]
 abi = { path = "../../abi" }
 embedded-graphics = "0.8.1"
-tinygif = "0.0.4"
+tinygif = { git = "https://github.com/LegitCamper/tinygif" }

user-apps/gif/src/main.rs

@@ -11,7 +11,9 @@ use abi::{
 };
 use alloc::vec;
 use core::panic::PanicInfo;
-use embedded_graphics::{image::ImageDrawable, pixelcolor::Rgb565};
+use embedded_graphics::{
+    image::ImageDrawable, pixelcolor::Rgb565, prelude::Point, transform::Transform,
+};
 use tinygif::Gif;
 
 #[panic_handler]
@@ -36,13 +38,17 @@ pub fn main() {
     assert!(read == size);
 
     let gif = Gif::<Rgb565>::from_slice(&buf).unwrap();
+    let height = gif.height();
 
     let mut frame_num = 0;
     loop {
-        for frame in gif.frames() {
+        for mut frame in gif.frames() {
             let start = get_ms();
 
-            frame.draw(&mut display).unwrap();
+            frame
+                .translate_mut(Point::new(0, (320 - height as i32) / 2))
+                .draw(&mut display)
+                .unwrap();
             frame_num += 1;
 
             if frame_num % 100 == 0 {