Merge pull request #34 from robyoung/allow-noncontiguous-pins-in-display

therealprof · web-flow · commit 8dae48ee8dd0 · 2021-04-18T22:36:06.000+02:00
Allow noncontiguous pins in display
diff --git a/examples/led_blocking.rs b/examples/led_blocking.rs
@@ -6,10 +6,9 @@ use panic_halt as _;
 
 use cortex_m_rt::entry;
 
-use microbit::hal::{
-    gpio::{p0::Parts as P0Parts, Level},
-    prelude::*,
-    Timer,
+use microbit::{
+    display_pins,
+    hal::{gpio::p0::Parts as P0Parts, prelude::*, Timer},
 };
 
 use microbit::led;
@@ -21,20 +20,7 @@ fn main() -> ! {
         let p0parts = P0Parts::new(p.GPIO);
 
         // Display
-        let pins = led::Pins {
-            row1: p0parts.p0_13.into_push_pull_output(Level::Low),
-            row2: p0parts.p0_14.into_push_pull_output(Level::Low),
-            row3: p0parts.p0_15.into_push_pull_output(Level::Low),
-            col1: p0parts.p0_04.into_push_pull_output(Level::Low),
-            col2: p0parts.p0_05.into_push_pull_output(Level::Low),
-            col3: p0parts.p0_06.into_push_pull_output(Level::Low),
-            col4: p0parts.p0_07.into_push_pull_output(Level::Low),
-            col5: p0parts.p0_08.into_push_pull_output(Level::Low),
-            col6: p0parts.p0_09.into_push_pull_output(Level::Low),
-            col7: p0parts.p0_10.into_push_pull_output(Level::Low),
-            col8: p0parts.p0_11.into_push_pull_output(Level::Low),
-            col9: p0parts.p0_12.into_push_pull_output(Level::Low),
-        };
+        let pins = display_pins!(p0parts);
         let mut leds = led::Display::new(pins);
 
         #[allow(non_snake_case)]
diff --git a/examples/led_nonblocking.rs b/examples/led_nonblocking.rs
@@ -11,8 +11,13 @@ use cortex_m_rt::entry;
 
 use microbit::{
     display::{self, image::GreyscaleImage, Display, Frame, MicrobitDisplayTimer, MicrobitFrame},
-    hal::rtc::{Rtc, RtcInterrupt},
-    pac::{self, interrupt, GPIO, RTC0, TIMER1},
+    display_pins,
+    gpio::DisplayPins,
+    hal::{
+        gpio::p0::Parts as P0Parts,
+        rtc::{Rtc, RtcInterrupt},
+    },
+    pac::{self, interrupt, RTC0, TIMER1},
 };
 
 fn heart_image(inner_brightness: u8) -> GreyscaleImage {
@@ -29,7 +34,7 @@ fn heart_image(inner_brightness: u8) -> GreyscaleImage {
 // We use TIMER1 to drive the display, and RTC0 to update the animation.
 // We set the TIMER1 interrupt to a higher priority than RTC0.
 
-static GPIO: Mutex<RefCell<Option<GPIO>>> = Mutex::new(RefCell::new(None));
+static LED_PINS: Mutex<RefCell<Option<DisplayPins>>> = Mutex::new(RefCell::new(None));
 static ANIM_TIMER: Mutex<RefCell<Option<Rtc<RTC0>>>> = Mutex::new(RefCell::new(None));
 static DISPLAY_TIMER: Mutex<RefCell<Option<MicrobitDisplayTimer<TIMER1>>>> =
     Mutex::new(RefCell::new(None));
@@ -52,9 +57,11 @@ fn main() -> ! {
             rtc0.enable_counter();
 
             let mut timer = MicrobitDisplayTimer::new(p.TIMER1);
-            let mut gpio = p.GPIO;
-            display::initialise_display(&mut timer, &mut gpio);
-            *GPIO.borrow(cs).borrow_mut() = Some(gpio);
+
+            let p0parts = P0Parts::new(p.GPIO);
+            let mut pins = display_pins!(p0parts);
+            display::initialise_display(&mut timer, &mut pins);
+            *LED_PINS.borrow(cs).borrow_mut() = Some(pins);
             *ANIM_TIMER.borrow(cs).borrow_mut() = Some(rtc0);
             *DISPLAY_TIMER.borrow(cs).borrow_mut() = Some(timer);
             *DISPLAY.borrow(cs).borrow_mut() = Some(Display::new());
@@ -78,9 +85,9 @@ fn main() -> ! {
 fn TIMER1() {
     cortex_m::interrupt::free(|cs| {
         if let Some(timer) = DISPLAY_TIMER.borrow(cs).borrow_mut().as_mut() {
-            if let Some(gpio) = GPIO.borrow(cs).borrow_mut().as_mut() {
+            if let Some(pins) = LED_PINS.borrow(cs).borrow_mut().as_mut() {
                 if let Some(d) = DISPLAY.borrow(cs).borrow_mut().as_mut() {
-                    display::handle_display_event(d, timer, gpio);
+                    display::handle_display_event(d, timer, pins);
                 }
             }
         }
diff --git a/examples/led_rtfm.rs b/examples/led_rtfm.rs
@@ -11,7 +11,12 @@ use panic_halt as _;
 
 use microbit::{
     display::{self, image::GreyscaleImage, Display, Frame, MicrobitDisplayTimer, MicrobitFrame},
-    hal::rtc::{Rtc, RtcInterrupt},
+    display_pins,
+    gpio::DisplayPins,
+    hal::{
+        gpio::p0::Parts as P0Parts,
+        rtc::{Rtc, RtcInterrupt},
+    },
     pac,
 };
 use rtic::app;
@@ -30,15 +35,15 @@ fn heart_image(inner_brightness: u8) -> GreyscaleImage {
 #[app(device = microbit::pac, peripherals = true)]
 const APP: () = {
     struct Resources {
-        gpio: pac::GPIO,
+        display_pins: DisplayPins,
         display_timer: MicrobitDisplayTimer<pac::TIMER1>,
         anim_timer: Rtc<pac::RTC0>,
         display: Display<MicrobitFrame>,
     }
 
     #[init]
     fn init(cx: init::Context) -> init::LateResources {
-        let mut p: pac::Peripherals = cx.device;
+        let p: pac::Peripherals = cx.device;
 
         // Starting the low-frequency clock (needed for RTC to work)
         p.CLOCK.tasks_lfclkstart.write(|w| unsafe { w.bits(1) });
@@ -53,23 +58,27 @@ const APP: () = {
         rtc0.enable_counter();
 
         let mut timer = MicrobitDisplayTimer::new(p.TIMER1);
-        display::initialise_display(&mut timer, &mut p.GPIO);
+
+        let p0parts = P0Parts::new(p.GPIO);
+        let mut pins = display_pins!(p0parts);
+
+        display::initialise_display(&mut timer, &mut pins);
 
         init::LateResources {
-            gpio: p.GPIO,
+            display_pins: pins,
             display_timer: timer,
             anim_timer: rtc0,
             display: Display::new(),
         }
     }
 
     #[task(binds = TIMER1, priority = 2,
-           resources = [display_timer, gpio, display])]
+           resources = [display_timer, display_pins, display])]
     fn timer1(mut cx: timer1::Context) {
         display::handle_display_event(
             &mut cx.resources.display,
             cx.resources.display_timer,
-            cx.resources.gpio,
+            cx.resources.display_pins,
         );
     }
 
diff --git a/src/display/control.rs b/src/display/control.rs
@@ -7,30 +7,39 @@
 use crate::pac;
 use tiny_led_matrix::DisplayControl;
 
-const fn bit_range(lo: usize, count: usize) -> u32 {
-    ((1 << count) - 1) << lo
+const fn pin_bits(pins: &[usize]) -> u32 {
+    let mut i: usize = 0;
+    let mut bits: u32 = 0;
+    while i < pins.len() {
+        bits |= 1 << pins[i];
+        i += 1;
+    }
+    bits
 }
 
 pub(crate) const MATRIX_COLS: usize = 9;
-const FIRST_COL_PIN: usize = 4;
-const LAST_COL_PIN: usize = FIRST_COL_PIN + MATRIX_COLS - 1;
-const COL_BITS: u32 = bit_range(FIRST_COL_PIN, MATRIX_COLS);
+const COLS: [usize; MATRIX_COLS] = [4, 5, 6, 7, 8, 9, 10, 11, 12];
+const COL_BITS: u32 = pin_bits(&COLS);
 
 pub(crate) const MATRIX_ROWS: usize = 3;
-const FIRST_ROW_PIN: usize = 13;
-const LAST_ROW_PIN: usize = FIRST_ROW_PIN + MATRIX_ROWS - 1;
-const ROW_BITS: u32 = bit_range(FIRST_ROW_PIN, MATRIX_ROWS);
+const ROWS: [usize; MATRIX_ROWS] = [13, 14, 15];
+const ROW_BITS: u32 = pin_bits(&ROWS);
 
 /// Wrapper for `nrf51::GPIO` for passing to the display code.
 ///
 /// This implements the `DisplayControl` trait.
 ///
 /// [`DisplayControl`]: tiny_led_matrix::DisplayControl
-pub(crate) struct MicrobitGpio<'a>(pub &'a pac::GPIO);
+pub(crate) struct MicrobitGpio;
 
-/// Returns the GPIO pin numbers corresponding to the columns in a ColumnSet.
-fn column_pins(cols: u32) -> u32 {
-    cols << FIRST_COL_PIN
+/// Returns the GPIO pin numbers corresponding to the columns in a Columnt et.
+fn column_pins(mut cols: u32) -> u32 {
+    let mut result = 0u32;
+    for pin in COLS.iter() {
+        result |= (cols & 1) << pin;
+        cols >>= 1;
+    }
+    result
 }
 
 /// Implementation of [`DisplayControl`] for the micro:bit's GPIO peripheral.
@@ -41,37 +50,42 @@ fn column_pins(cols: u32) -> u32 {
 /// state it would have after system reset.
 ///
 /// [`DisplayControl`]: tiny_led_matrix::DisplayControl
-impl DisplayControl for MicrobitGpio<'_> {
+impl DisplayControl for MicrobitGpio {
     fn initialise_for_display(&mut self) {
-        let gpio = &self.0;
-        for ii in FIRST_COL_PIN..=LAST_COL_PIN {
-            gpio.pin_cnf[ii].write(|w| w.dir().output());
-        }
-        for ii in FIRST_ROW_PIN..=LAST_ROW_PIN {
-            gpio.pin_cnf[ii].write(|w| w.dir().output());
-        }
+        unsafe {
+            let gpio = &*pac::GPIO::ptr();
+            for ii in COLS.iter() {
+                gpio.pin_cnf[*ii].write(|w| w.dir().output());
+            }
+            for ii in ROWS.iter() {
+                gpio.pin_cnf[*ii].write(|w| w.dir().output());
+            }
 
-        // Set all cols high.
-        gpio.outset
-            .write(|w| unsafe { w.bits((FIRST_COL_PIN..=LAST_COL_PIN).map(|pin| 1 << pin).sum()) });
+            // Set all cols high.
+            gpio.outset
+                .write(|w| w.bits(COLS.iter().map(|pin| 1 << pin).sum()));
+        }
     }
 
     fn display_row_leds(&mut self, row: usize, cols: u32) {
-        let gpio = &self.0;
-        // To light an LED, we set the row bit and clear the col bit.
-        let rows_to_set = 1 << (FIRST_ROW_PIN + row);
-        let rows_to_clear = ROW_BITS ^ rows_to_set;
-        let cols_to_clear = column_pins(cols);
-        let cols_to_set = COL_BITS ^ cols_to_clear;
+        unsafe {
+            let gpio = &*pac::GPIO::ptr();
+            // To light an LED, we set the row bit and clear the col bit.
+            let rows_to_set = 1 << ROWS[row];
+            let rows_to_clear = ROW_BITS ^ rows_to_set;
+
+            let cols_to_clear = column_pins(cols);
+            let cols_to_set = COL_BITS ^ cols_to_clear;
 
-        gpio.outset
-            .write(|w| unsafe { w.bits(rows_to_set | cols_to_set) });
-        gpio.outclr
-            .write(|w| unsafe { w.bits(rows_to_clear | cols_to_clear) });
+            gpio.outset.write(|w| w.bits(rows_to_set | cols_to_set));
+            gpio.outclr.write(|w| w.bits(rows_to_clear | cols_to_clear));
+        }
     }
 
     fn light_current_row_leds(&mut self, cols: u32) {
-        let gpio = &self.0;
-        gpio.outclr.write(|w| unsafe { w.bits(column_pins(cols)) });
+        unsafe {
+            let gpio = &*crate::pac::GPIO::ptr();
+            gpio.outclr.write(|w| w.bits(column_pins(cols)));
+        }
     }
 }
diff --git a/src/display/image.rs b/src/display/image.rs
@@ -29,6 +29,7 @@ impl GreyscaleImage {
         GreyscaleImage(*data)
     }
 
+    /// Construct a GreyscaleImage with all LEDs turned off.
     pub const fn blank() -> GreyscaleImage {
         GreyscaleImage([[0; 5]; 5])
     }
diff --git a/src/display/mod.rs b/src/display/mod.rs
@@ -47,8 +47,8 @@
 //! The [`Render`] trait defines the interface that an image-like type needs
 //! to provide in order to be displayed.
 //!
-//! It contains a single function: [`brightness_at(x,
-//! y)`][display::Render::brightness_at], returning a brightness level.
+//! It contains a single function: [`brightness_at(x, y)`](Render::brightness_at),
+//! returning a brightness level.
 //!
 //! The [`image`] submodule provides two static image types implementing
 //! `Render`:
@@ -77,7 +77,7 @@
 //!
 //! # Timer integration
 //!
-//! The `Display` expects to control a single timer. It can use the
+//! The [`Display`] expects to control a single timer. It can use the
 //! micro:bit's `TIMER0`, `TIMER1`, or `TIMER2`.
 //!
 //! This uses a 6ms period to light each of the three internal LED rows, so
@@ -100,14 +100,14 @@
 //! When your program starts:
 //! * create a [`MicrobitDisplayTimer`] struct, passing the timer you chose to
 //! [`MicrobitDisplayTimer::new()`]
-//! * call [`initialise_display()`], passing it the `MicrobitDisplayTimer` and
-//! the gpio peripheral
+//! * call [`initialise_display()`], passing it the `MicrobitDisplayTimer` and the
+//! [`crate::led::Pins`]
 //! * create a [`Display`] struct (a `Display<MicrobitFrame>`).
 //!
 //! In an interrupt handler for the timer, call [`handle_display_event()`].
 //!
 //! To change what's displayed: create a [`MicrobitFrame`] instance, use
-//! [`.set()`](`display::Frame::set()`) to put an image (something implementing
+//! [`.set()`](`Frame::set()`) to put an image (something implementing
 //! [`Render`]) in it, then call [`Display::set_frame()`]. Note you'll have to
 //! `use microbit::display::Frame` to make `set()` available.
 //!
@@ -121,22 +121,6 @@
 //!
 //! [dal]: https://lancaster-university.github.io/microbit-docs/
 //! [micropython]: https://microbit-micropython.readthedocs.io/
-//!
-//! [`BitImage`]: display::image::BitImage
-//! [`Display`]: display::Display
-//! [`Display::set_frame()`]: display::Display::set_frame
-//! [`Frame`]: display::Frame
-//! [`Matrix`]: display::Matrix
-//! [`MicrobitFrame`]: display::MicrobitFrame
-//! [`MicrobitDisplayTimer`]: display::MicrobitDisplayTimer
-//! [`MicrobitDisplayTimer::new()`]: display::MicrobitDisplayTimer::new
-//! [`Render`]: display::Render
-//! [`image`]: display::image
-//! [`handle_display_event()`]: display::handle_display_event
-//! [`initialise_display()`]: display::initialise_display
-//! [`DisplayTimer`]: tiny_led_matrix::DisplayTimer
-//! [`GreyscaleImage`]: display::image::GreyscaleImage
-//!
 
 #[doc(no_inline)]
 pub use tiny_led_matrix::{Display, Frame, Render, MAX_BRIGHTNESS};
@@ -150,7 +134,7 @@ pub mod image;
 pub use matrix::MicrobitFrame;
 pub use timer::MicrobitDisplayTimer;
 
-use crate::hal::timer::Instance;
+use crate::{gpio::DisplayPins, hal::timer::Instance};
 
 use control::MicrobitGpio;
 
@@ -167,9 +151,9 @@ use control::MicrobitGpio;
 /// ```
 pub fn initialise_display<T: Instance>(
     timer: &mut MicrobitDisplayTimer<T>,
-    gpio: &mut crate::pac::GPIO,
+    _pins: &mut DisplayPins,
 ) {
-    tiny_led_matrix::initialise_control(&mut MicrobitGpio(gpio));
+    tiny_led_matrix::initialise_control(&mut MicrobitGpio {});
     tiny_led_matrix::initialise_timer(timer);
 }
 
@@ -202,7 +186,7 @@ pub fn initialise_display<T: Instance>(
 pub fn handle_display_event<T: Instance>(
     display: &mut Display<MicrobitFrame>,
     timer: &mut MicrobitDisplayTimer<T>,
-    gpio: &mut crate::pac::GPIO,
+    _pins: &mut DisplayPins,
 ) {
-    display.handle_event(timer, &mut MicrobitGpio(gpio));
+    display.handle_event(timer, &mut MicrobitGpio {});
 }
diff --git a/src/gpio.rs b/src/gpio.rs
diff --git a/src/led.rs b/src/led.rs
diff --git a/src/lib.rs b/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ impl GreyscaleImage {`
`29`	`29`	`GreyscaleImage(*data)`
`30`	`30`	`}`
`31`	`31`
	`32`	`+ /// Construct a GreyscaleImage with all LEDs turned off.`
`32`	`33`	`pub const fn blank() -> GreyscaleImage {`
`33`	`34`	`GreyscaleImage([[0; 5]; 5])`
`34`	`35`	`}`