Switch config sharing from handoff to watch.

Not only is it better specified, it's significantly smaller in flash!

Author: cbiffle

Cargo.lock

@@ -17,15 +17,13 @@ futures = { version = "0.3.28", default-features = false, features = ["async-awa
 panic-halt = {optional = true, version = "0.2.0"}
 panic-semihosting = {optional = true, version = "0.6.0"}
 scopeguard = { version = "1.1.0", default-features = false }
+lilos-watch = "0.1"
 
 [dependencies.lilos]
-version = "1.0.0"
+version = "1.2"
 default-features = false
 features = ["spsc", "systick"]
 
-[dependencies.lilos-handoff]
-version = "1.0.0"
-
 [dependencies.stm32-metapac]
 default-features = false
 features = ["rt", "pac"]

Cargo.toml

@@ -277,10 +277,10 @@ fn main() -> ! {
  let mut scan_event_q = pin!(Queue::new(SCAN_EVENT_Q.take()));
  let (scan_event_from_scanner, scan_event_to_serial) = scan_event_q.split();
 
- // Allocate the serial-to-scanner synchronous config handoff (no storage
- // required)
- let mut config_handoff = lilos_handoff::Handoff::new();
- let (config_to_scanner, config_from_serial) = config_handoff.split();
+ // Allocate the serial-to-scanner synchronous config watcher.
+ let config_watch = lilos_watch::Watch::new(cfg.scanner);
+ let config_to_scanner = config_watch.sender();
+ let config_from_serial = config_watch.subscribe();
 
  // Create the serial-to-I2C byte queue using static storage.
  let mut i2c_byte_q = pin!(Queue::new(I2C_Q.take()));
@@ -298,7 +298,6 @@ fn main() -> ! {
  ));
 
  let scanner_task = pin!(scanner::task(
- cfg.scanner,
  config_from_serial,
  gpioa,
  scan_event_from_scanner,

src/main.rs

@@ -151,59 +151,63 @@ pub enum KeyState { #[default] Up, Down }
 
 /// Keypad scanner loop.
 ///
-/// Pass this its initial `config` plus a handoff channel through which it can
+/// Pass this its initial `config` plus a watch channel through which it can
 /// receive updated configs. It'll scan the provided GPIO port (pins 0-7) and
 /// emit events through `out_queue`.
 pub async fn task(
- mut config: Config,
- mut config_update: lilos_handoff::Popper<'_, Config>,
+ mut config_update: lilos_watch::Receiver<'_, Config>,
  gpio: device::gpio::Gpio,
  mut out_queue: spsc::Pusher<'_, KeyEvent>,
 ) -> Infallible {
  configure_pins(gpio);
 
+ // Make a copy of the config so we can be specific about changes.
+ let mut config = config_update.copy_current();
+
  let debouncers = DEBOUNCERS.take();
  let mut scan_gate = PeriodicGate::from(SCAN_INTERVAL);
  loop {
  scan_gate.next_time().await;
 
  // Process any config update before starting the scan.
- if let Some(new_config) = config_update.try_pop() {
- // Handle any "killed" drive lines. This occurs when the
- // `driven_lines` bit was 1 in the old config, and is becoming 0.
- // When a drive line is killed we need to reset the state of its
- // debouncers so they don't do anything.
- for (line, debounce_row) in debouncers.iter_mut().enumerate() {
- let line_mask = 1 << line;
- let in_use_before = config.driven_lines & line_mask != 0;
- let still_in_use = new_config.driven_lines & line_mask != 0;
- if in_use_before && !still_in_use {
- for debouncer in debounce_row {
- *debouncer = Default::default();
+ if config_update.is_changed() {
+ config_update.glimpse_and_update(|new_config| {
+ // Handle any "killed" drive lines. This occurs when the
+ // `driven_lines` bit was 1 in the old config, and is becoming 0.
+ // When a drive line is killed we need to reset the state of its
+ // debouncers so they don't do anything.
+ for (line, debounce_row) in debouncers.iter_mut().enumerate() {
+ let line_mask = 1 << line;
+ let in_use_before = config.driven_lines & line_mask != 0;
+ let still_in_use = new_config.driven_lines & line_mask != 0;
+ if in_use_before && !still_in_use {
+ for debouncer in debounce_row {
+ *debouncer = Default::default();
+ }
  }
  }
- }
- // Handle any "killed" keys. This occurs when the key's bit in the
- // `ghost_mask` was not set before, but has become set. As in the
- // killed line case, we need to reset its debouncer state.
- //
- // This is written using a range and indexing because, believe it or
- // not, enumerate generates much larger code -- at least as of
- // 1.75.0. This is because we're at opt-level="z", which makes dumb
- // decisions like "not inlining the enumerate iterator for slices."
- #[allow(clippy::needless_range_loop)]
- for line in 0..8 {
- for col in 0..8 {
- let col_mask = 1 << col;
- let real_before = config.ghost_mask[line] & col_mask == 0;
- let still_real = new_config.ghost_mask[line] & col_mask != 0;
- if real_before && !still_real {
- debouncers[line][col] = Default::default();
+  // Handle any "killed" keys. This occurs when the key's bit in the
+  // `ghost_mask` was not set before, but has become set. As in the
+  // killed line case, we need to reset its debouncer state.
+  //
+  // This is written using a range and indexing because, believe it or
+  // not, enumerate generates much larger code -- at least as of
+  // 1.75.0. This is because we're at opt-level="z", which makes dumb
+  // decisions like "not inlining the enumerate iterator for slices."
+  #[allow(clippy::needless_range_loop)]
+  for line in 0..8 {
+  for col in 0..8 {
+  let col_mask = 1 << col;
+  let real_before = config.ghost_mask[line] & col_mask == 0;
+  let still_real = new_config.ghost_mask[line] & col_mask != 0;
+  if real_before && !still_real {
+  debouncers[line][col] = Default::default();
+ }
  }
  }
- }
- // Apply the config.
- config = new_config;
+  // Apply the config.
+  config = *new_config;
+ });
  }
  // Config doesn't get modified anywhere else in this loop -- see:
  let config = &config;

src/scanner.rs

@@ -84,7 +84,7 @@ pub async fn task(
  keymap: &[[u8; 8]; 8],
  setup_mode: bool,
  mut from_scanner: spsc::Popper<'_, scanner::KeyEvent>,
- config_to_scanner: lilos_handoff::Pusher<'_, scanner::Config>,
+ config_to_scanner: lilos_watch::Sender<'_, scanner::Config>,
  mut bytes_to_i2c: spsc::Pusher<'_, u8>,
  storage: Storage,
 ) -> Infallible {
@@ -348,7 +348,7 @@ const SETTLE: Millis = Millis(100);
 /// so, during setup the I2C port will be dead.
 async fn setup(
  uart: Uart,
- mut config_to_scanner: lilos_handoff::Pusher<'_, scanner::Config>,
+ config_to_scanner: lilos_watch::Sender<'_, scanner::Config>,
  mut from_scanner: lilos::spsc::Popper<'_, scanner::KeyEvent>,
  mut storage: Storage,
 ) -> Infallible {
@@ -360,14 +360,14 @@ async fn setup(
  // configuration has been applied (which will use this epoch).
  const SETUP_EPOCH: u8 = 0x55;
 
- config_to_scanner.push(scanner::Config {
+ config_to_scanner.send(scanner::Config {
  // Recognizable epoch in case we raced the scan
  epoch: SETUP_EPOCH,
  // All lines should be driven during setup.
  driven_lines: 0xFF,
  // No ghost keys should be ignored, we want to know about everything.
  ghost_mask: [0; 8],
- }).await;
+ });
 
  transmit(uart, concat!(
  "\r\n\
@@ -580,11 +580,11 @@ async fn setup(
 
  // Push the configuration over whether or not we saved it, so we can run the
  // demo loop.
- config_to_scanner.push(scanner::Config {
+ config_to_scanner.send(scanner::Config {
  epoch: DEMO_EPOCH,
  driven_lines,
  ghost_mask,
- }).await;
+ });
 
  transmit(uart, b"Running demo until reset:\r\n").await;