Upgrade to latest chirp8-engine

Author: gergoerdi

chirp8-engine

@@ -0,0 +1,62 @@
+use pcd8544;
+use chirp8::prelude::*;
+
+const FB_X_START: u8 = (pcd8544::SCREEN_WIDTH - SCREEN_WIDTH) / 2;
+const FB_X_END: u8 = FB_X_START + SCREEN_WIDTH;
+const FB_Y_START: u8 = (pcd8544::SCREEN_HEIGHT - SCREEN_HEIGHT) / 2;
+const FB_Y_END: u8 = FB_Y_START + SCREEN_HEIGHT;
+
+pub struct FBIter<'a> {
+    data: &'a [u64; SCREEN_HEIGHT as usize],
+    x: u8,
+    y: u8
+}
+
+impl<'a> FBIter<'a> {
+    pub fn new(data: &'a [u64; SCREEN_HEIGHT as usize]) -> FBIter<'a> {
+        FBIter {
+            data: data,
+            x: 0,
+            y: 0
+        }
+    }
+
+    fn stripe(&self) -> Option<u8> {
+        if self.x < FB_X_START || self.x >= FB_X_END { return None };
+        let x = self.x - FB_X_START;
+        if self.y < FB_Y_START || self.y >= FB_Y_END { return None };
+        let y = self.y - FB_Y_START;
+
+        let mut stripe = 0x00;
+        let mask = 1 << (63 - x);
+
+        for i in (y..y+8).rev() {
+            let row: u64 = self.data[i as usize];
+            let pixel = if row & mask == 0 { 0 } else { 1 };
+
+            stripe = (stripe << 1) | pixel;
+        }
+
+        Some(stripe)
+    }
+}
+
+impl<'a> Iterator for FBIter<'a> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.x >= pcd8544::SCREEN_WIDTH {
+            return None
+        }
+
+        let result = self.stripe();
+
+        self.y += 8;
+        if self.y >= pcd8544::SCREEN_HEIGHT {
+            self.y = 0;
+            self.x += 1;
+        }
+
+        Some(result.unwrap_or(0x00))
+    }
+}

src/framebuffer.rs

@@ -20,70 +20,44 @@ mod timer;
 mod keypad;
 mod serial_ram;
 mod rom;
+mod framebuffer;
 
 use rom::*;
 use timer::sleep_ms;
+use framebuffer::FBIter;
 
 use chirp8::prelude::*;
 use chirp8::peripherals::*;
 
 struct Board {
     fb_dirty: bool,
-    fb_pixels: [[u8; (pcd8544::SCREEN_HEIGHT / 8) as usize]; pcd8544::SCREEN_WIDTH as usize],
+    fb_rows: [u64; SCREEN_HEIGHT as usize],
     countdown: u8
 }
 
 impl Board {
     pub const fn new() -> Board {
         Board {
             fb_dirty: false,
-            fb_pixels: [[0; (pcd8544::SCREEN_HEIGHT / 8) as usize]; pcd8544::SCREEN_WIDTH as usize],
+            fb_rows: [0; SCREEN_HEIGHT as usize],
             countdown: 0
         }
     }
 }
 static mut BOARD: Board = Board::new();
 
-fn xy_from_chirp8(x: u8, y: u8) -> (u8, u8) {
-    let dx = (pcd8544::SCREEN_WIDTH - SCREEN_WIDTH) / 2;
-    let dy = (pcd8544::SCREEN_HEIGHT - SCREEN_HEIGHT) / 2;
-    (x + dx, y + dy)
-}
-
 impl Peripherals for Board {
     fn keep_running(&self) -> bool { true }
 
-    fn clear_pixels(&mut self) {
-        for col in self.fb_pixels.iter_mut() {
-            for pixel in col.iter_mut() {
-                *pixel = 0;
-            }
-        }
-        self.fb_dirty = true
+    fn get_pixel_row(&self, y: u8) -> u64 {
+        self.fb_rows[y as usize]
     }
 
-    fn set_pixel(&mut self, x: Byte, y: Byte, v: bool) {
-        let (x, y) = xy_from_chirp8(x, y);
-
-        let row = y >> 3;
-        let offset = y - (row << 3);
-        let mask = 1 << offset;
-        let bit = (if v {1} else {0}) << offset;
-
-        self.fb_pixels[x as usize][row as usize] = (self.fb_pixels[x as usize][row as usize] & !mask) | bit;
+    fn set_pixel_row(&mut self, y: u8, row: u64) {
+        self.fb_rows[y as usize] = row;
         self.fb_dirty = true;
     }
 
-    fn get_pixel(&self, x: Byte, y: Byte) -> bool {
-        let (x, y) = xy_from_chirp8(x, y);
-
-        let row = y >> 3;
-        let offset = y - (row << 3);
-        let mask = 1 << offset;
-
-        self.fb_pixels[x as usize][row as usize] & mask != 0
-    }
-
     fn redraw(&mut self) {
         // Not really needed? timer will take care of it?
     }
@@ -140,7 +114,7 @@ impl Peripherals for Board {
 pub fn redraw() {
     let board = unsafe{ &mut BOARD };
     if board.fb_dirty {
-        pcd8544::send(&board.fb_pixels);
+        pcd8544::send(FBIter::new(&board.fb_rows));
         board.fb_dirty = false;
     }
 }
@@ -153,19 +127,23 @@ pub fn tick() {
 fn draw_test_pattern(board: &mut Board) {
     let dx = (SCREEN_WIDTH - SCREEN_HEIGHT) / 2;
 
-    for i in 0..SCREEN_HEIGHT {
-        board.set_pixel(i + dx, SCREEN_HEIGHT - (i + 1), false);
-        board.set_pixel(i + dx, i, true);
+    let mut row: u64 = 1 << 47;
+    for i in 0..32 {
+        board.set_pixel_row(i, row);
+        row >>= 1;
     }
+    sleep_ms(500);
 
+    let mut row: u64 = 1 << 47;
+    for i in (0..32).rev() {
+        board.set_pixel_row(i, row);
+        row >>= 1;
+    }
     sleep_ms(500);
 
     for i in 0..SCREEN_HEIGHT {
-        board.set_pixel(i + dx, SCREEN_HEIGHT - (i + 1), true);
-        board.set_pixel(i + dx, i, false);
+        board.set_pixel_row(i, 0)
     }
-    sleep_ms(500);
-    board.clear_pixels();
 }
 
 #[no_mangle]

src/main.rs

@@ -32,7 +32,7 @@ pub fn setup() {
     port::D3::set_high(); // Unselect LCD
 }
 
-pub fn send(pixels: &[[u8; (SCREEN_HEIGHT / 8) as usize]; SCREEN_WIDTH as usize]) {
+pub fn send<I>(pixels: I) where I: IntoIterator<Item = u8> {
     port::D3::set_low(); // Chip select LCD
     port::D5::set_low(); // Set Command mode
 
@@ -41,10 +41,8 @@ pub fn send(pixels: &[[u8; (SCREEN_HEIGHT / 8) as usize]; SCREEN_WIDTH as usize]
     spi::sync(0x40 | 0);   // Set Y address
 
     port::D5::set_high(); // Set Data mode
-    for col in pixels.iter() {
-        for &pixel in col.iter() {
-            spi::sync(pixel);
-        }
+    for stripe in pixels.into_iter() {
+        spi::sync(stripe);
     }
 
     port::D3::set_high(); // Unselect LCD