feat: add SerialHandler-based sync messages

Author: zabackary

src/countdown.rs

@@ -1,6 +1,6 @@
 use core::cell::RefCell;
 
-use arduino_hal::{delay_ms, Delay};
+use arduino_hal::{delay_ms, hal::Atmega, usart::UsartOps, Delay};
 use embedded_hal::digital::v2::{InputPin, OutputPin};
 use hd44780_driver::{bus::DataBus, HD44780};
 use ufmt::uwrite;
@@ -9,6 +9,7 @@ use crate::{
     error::RuntimeError,
     lcd_writer::LcdWriter,
     millis::millis,
+    serial::{SerialHandler, SerialMsg},
     time_set::{render_time, TimeSetting},
     LCD_LINE_LENGTH,
 };
@@ -28,11 +29,21 @@ pub enum Turn {
     P2,
 }
 
-pub fn countdown<DP: InputPin, UP: InputPin, SP: InputPin, BP: OutputPin, B: DataBus>(
+pub fn countdown<
+    DP: InputPin,
+    UP: InputPin,
+    SP: InputPin,
+    BP: OutputPin,
+    B: DataBus,
+    USART: UsartOps<Atmega, RX, TX>,
+    RX,
+    TX,
+>(
     down_pin: &mut DP,
     up_pin: &mut UP,
     start_pin: &mut SP,
     buzzer_pin: &mut BP,
+    serial_handler: &mut SerialHandler<USART, RX, TX>,
     delay: &mut Delay,
     lcd: &RefCell<HD44780<B>>,
     writer: &mut LcdWriter<'_, B>,
@@ -110,6 +121,8 @@ pub fn countdown<DP: InputPin, UP: InputPin, SP: InputPin, BP: OutputPin, B: Dat
             delay_ms(LOOP_DELAY);
         }
 
+        let _msg = serial_handler.read().ok();
+
         if start.update(start_pin.is_low().map_err(|_| RuntimeError::PinReadError)?)
             == Some(debouncr::Edge::Falling)
         {
@@ -132,6 +145,9 @@ pub fn countdown<DP: InputPin, UP: InputPin, SP: InputPin, BP: OutputPin, B: Dat
             // Down/P1 press (switch to P2)
             // Unsafe subtraction since it's already been checked in the rendering code
             p1_ms_at_change = p1_ms_at_change - time_since_change;
+            let _ = serial_handler.write(SerialMsg::StartP2 {
+                p1_time: p1_ms_at_change, // TODO: fix this
+            });
             last_change_time = millis();
             *turn = Turn::P2
         }
@@ -142,6 +158,9 @@ pub fn countdown<DP: InputPin, UP: InputPin, SP: InputPin, BP: OutputPin, B: Dat
             // Up/P2 press (switch to P1)
             // Unsafe subtraction since it's already been checked in the rendering code
             p2_ms_at_change = p2_ms_at_change - time_since_change;
+            let _ = serial_handler.write(SerialMsg::StartP1 {
+                p2_time: p2_ms_at_change, // TODO: fix this
+            });
             last_change_time = millis();
             *turn = Turn::P1;
         }

src/finish.rs

@@ -1,17 +1,18 @@
 use core::cell::RefCell;
 
-use arduino_hal::{delay_ms, Delay};
+use arduino_hal::{delay_ms, hal::Atmega, usart::UsartOps, Delay};
 use embedded_hal::digital::v2::{InputPin, OutputPin};
 use hd44780_driver::{bus::DataBus, HD44780};
 use ufmt::uwrite;
 
-use crate::{countdown::Turn, error::RuntimeError, lcd_writer::LcdWriter};
+use crate::{countdown::Turn, error::RuntimeError, lcd_writer::LcdWriter, serial::SerialHandler};
 
 const LOOP_DELAY: u16 = 5;
 const BUZZER_LENGTH: u16 = 120;
 
-pub fn finish<SP: InputPin, BP: OutputPin, B: DataBus>(
+pub fn finish<SP: InputPin, BP: OutputPin, B: DataBus, USART: UsartOps<Atmega, RX, TX>, RX, TX>(
     loser: &Turn,
+    _serial_handler: &mut SerialHandler<USART, RX, TX>,
     delay: &mut Delay,
     lcd: &RefCell<HD44780<B>>,
     writer: &mut LcdWriter<'_, B>,

src/main.rs

@@ -12,7 +12,7 @@ use error::RuntimeError;
 use hd44780_driver::{bus::DataBus, DisplayMode, HD44780};
 use lcd_writer::LcdWriter;
 use panic_halt as _;
-use serial::SerialHandler;
+use serial::{SerialHandler, SerialMsg};
 use ufmt::uwrite;
 use void::ResultVoidExt;
 
@@ -169,6 +169,7 @@ fn runtime<
             &mut down_btn,
             &mut up_btn,
             &mut start_btn,
+            &mut serial_handler,
             lcd_delay,
             &lcd,
             writer,
@@ -189,11 +190,20 @@ fn runtime<
             pause::PauseResult::Stopped => continue 'main,
         };
         let loser = loop {
+            serial_handler.write(match turn {
+                Turn::P1 => SerialMsg::StartP1 {
+                    p2_time: times.1.into_millis(),
+                },
+                Turn::P2 => SerialMsg::StartP2 {
+                    p1_time: times.0.into_millis(),
+                },
+            });
             match countdown::countdown(
                 &mut down_btn,
                 &mut up_btn,
                 &mut start_btn,
                 &mut buzzer,
+                &mut serial_handler,
                 lcd_delay,
                 &lcd,
                 writer,
@@ -205,6 +215,12 @@ fn runtime<
                 countdown::CountdownResult::FinishedP2 => break Turn::P2,
                 countdown::CountdownResult::Paused => (),
             }
+            serial_handler.write(SerialMsg::Pause {
+                time: match turn {
+                    Turn::P1 => times.0.into_millis(),
+                    Turn::P2 => times.1.into_millis(),
+                },
+            });
             match pause::pause(
                 &mut down_btn,
                 &mut up_btn,
@@ -221,6 +237,18 @@ fn runtime<
                 pause::PauseResult::Stopped => continue 'main,
             }
         };
-        finish::finish(&loser, lcd_delay, &lcd, writer, &mut start_btn, &mut buzzer)?;
+        serial_handler.write(match loser {
+            Turn::P1 => SerialMsg::P1Finish,
+            Turn::P2 => SerialMsg::P2Finish,
+        });
+        finish::finish(
+            &loser,
+            &mut serial_handler,
+            lcd_delay,
+            &lcd,
+            writer,
+            &mut start_btn,
+            &mut buzzer,
+        )?;
     }
 }

src/serial.rs

@@ -1,51 +1,75 @@
 use arduino_hal::{hal::Atmega, usart::UsartOps, Usart};
 use embedded_hal::serial::{Read, Write};
+use void::ResultVoidExt;
 
 use crate::millis::millis;
 
-/// Note: all arguments are big-endian
+/// The types of sendable messages.
+/// Keep up to date with /src/serial.rs
+///
+/// Note: all messages are big-endian
 pub enum SerialMsg {
     /// Just send HandshakeResponse back if you get this.
     ///
-    /// 0x00
-    Handshake,
+    /// Parameter: mode
+    ///   0x0000 - let the other party decide
+    ///   0x0001 - sync
+    ///   0x0002 - other party is slave
+    ///   0x0003 - other party is master
+    ///
+    /// 0xc0
+    Handshake { mode: u32 },
     /// Yay, Handshake was successful!
     ///
-    /// 0x01
-    HandshakeResponse,
-    /// P1 is now counting down, and P2 has the specified # of ms. This will
-    /// wrap after about an hour.
+    /// Parameter: selected_mode
+    ///   0x0000 - mode not supported
+    ///   0x0001 - sync
+    ///   0x0002 - we're slave
+    ///   0x0003 - we're master
+    ///
+    /// 0xc1
+    HandshakeResponse { selected_mode: u32 },
+    /// P1 is now counting down, and P2 has the specified # of ms.
     ///
-    /// 0x02
-    StartP1 { p2_time: u16 },
-    /// P2 is now counting down, and P1 has the specified # of ms. This will
-    /// wrap after about an hour.
+    /// 0xc2
+    StartP1 { p2_time: u32 },
+    /// P2 is now counting down, and P1 has the specified # of ms.
     ///
-    /// 0x03
-    StartP2 { p1_time: u16 },
+    /// 0xc3
+    StartP2 { p1_time: u32 },
     /// Syncing time. P1 first, then P2, in ms.
     ///
-    /// 0x04
-    Sync { p1_time: u16, p2_time: u16 },
+    /// 0xc4
+    Sync { p1_time: u32, p2_time: u32 },
     /// Pause both times. The currently running clock finished at the specified
     /// ms.
     ///
-    /// 0x05
-    Pause { time: u16 },
+    /// 0xc5
+    Pause { time: u32 },
+    /// P1 won by time.
+    ///
+    /// 0xc6
+    P1Finish,
+    /// P2 won by time.
+    ///
+    /// 0xc7
+    P2Finish,
 }
 
 impl SerialMsg {
     fn to_u8(&self) -> u8 {
         match *self {
-            SerialMsg::Handshake => 0x00,
-            SerialMsg::HandshakeResponse => 0x01,
-            SerialMsg::StartP1 { p2_time: _ } => 0x02,
-            SerialMsg::StartP2 { p1_time: _ } => 0x03,
+            SerialMsg::Handshake { mode: _ } => 0xc0,
+            SerialMsg::HandshakeResponse { selected_mode: _ } => 0xc1,
+            SerialMsg::StartP1 { p2_time: _ } => 0xc2,
+            SerialMsg::StartP2 { p1_time: _ } => 0xc3,
             SerialMsg::Sync {
                 p1_time: _,
                 p2_time: _,
-            } => 0x04,
-            SerialMsg::Pause { time: _ } => 0x05,
+            } => 0xc4,
+            SerialMsg::Pause { time: _ } => 0xc5,
+            SerialMsg::P1Finish => 0xc6,
+            SerialMsg::P2Finish => 0xc7,
         }
     }
 }
@@ -56,59 +80,72 @@ pub struct SerialHandler<USART: UsartOps<Atmega, RX, TX>, RX, TX> {
     pub connected: bool,
 }
 
+/// Handles serial communication between the firmware and website.
+/// Keep up to date with /www/src/serial.ts
 impl<USART: UsartOps<Atmega, RX, TX>, RX, TX> SerialHandler<USART, RX, TX> {
-    fn write_u16(&mut self, v: u16) -> nb::Result<(), void::Void> {
+    fn write_u32(&mut self, v: u32) {
         let bytes = v.to_be_bytes();
-        self.serial.write(bytes[0])?;
-        self.serial.write(bytes[1])?;
-        Ok(())
+        for byte in bytes {
+            nb::block!(self.serial.write(byte)).void_unwrap();
+        }
     }
 
-    pub fn write(&mut self, msg: SerialMsg) -> nb::Result<(), void::Void> {
-        self.serial.write(msg.to_u8())?;
+    pub fn write(&mut self, msg: SerialMsg) {
+        self.serial.write_byte(msg.to_u8());
         match msg {
-            SerialMsg::Handshake => {}
-            SerialMsg::HandshakeResponse => {}
+            SerialMsg::Handshake { mode } => {
+                self.write_u32(mode);
+            }
+            SerialMsg::HandshakeResponse { selected_mode } => {
+                self.write_u32(selected_mode);
+            }
             SerialMsg::StartP1 { p2_time } => {
-                self.write_u16(p2_time)?;
+                self.write_u32(p2_time);
             }
             SerialMsg::StartP2 { p1_time } => {
-                self.write_u16(p1_time)?;
+                self.write_u32(p1_time);
             }
             SerialMsg::Sync { p1_time, p2_time } => {
-                self.write_u16(p1_time)?;
-                self.write_u16(p2_time)?;
+                self.write_u32(p1_time);
+                self.write_u32(p2_time);
             }
             SerialMsg::Pause { time } => {
-                self.write_u16(time)?;
+                self.write_u32(time);
             }
+            SerialMsg::P1Finish => {}
+            SerialMsg::P2Finish => {}
         }
-        Ok(())
+    }
+
+    fn read_u32(&mut self) -> u32 {
+        ((nb::block!(self.serial.read()).void_unwrap() as u32) << 24)
+            | ((nb::block!(self.serial.read()).void_unwrap() as u32) << 16)
+            | ((nb::block!(self.serial.read()).void_unwrap() as u32) << 8)
+            | nb::block!(self.serial.read()).void_unwrap() as u32
     }
 
     /// Reads a raw message from the wire and blocks until it's completely received.
     fn raw_read(&mut self) -> nb::Result<SerialMsg, void::Void> {
         let msg = self.serial.read()?;
         match msg {
-            0x00 => Ok(SerialMsg::Handshake),
-            0x01 => Ok(SerialMsg::HandshakeResponse),
-            0x02 => Ok(SerialMsg::StartP1 {
-                p2_time: ((nb::block!(self.serial.read())? as u16) << 8)
-                    | nb::block!(self.serial.read())? as u16,
+            0xc0 => Ok(SerialMsg::Handshake {
+                mode: self.read_u32(),
+            }),
+            0xc1 => Ok(SerialMsg::HandshakeResponse {
+                selected_mode: self.read_u32(),
+            }),
+            0xc2 => Ok(SerialMsg::StartP1 {
+                p2_time: self.read_u32(),
             }),
-            0x03 => Ok(SerialMsg::StartP2 {
-                p1_time: ((nb::block!(self.serial.read())? as u16) << 8)
-                    | nb::block!(self.serial.read())? as u16,
+            0xc3 => Ok(SerialMsg::StartP2 {
+                p1_time: self.read_u32(),
             }),
-            0x04 => Ok(SerialMsg::Sync {
-                p1_time: ((nb::block!(self.serial.read())? as u16) << 8)
-                    | nb::block!(self.serial.read())? as u16,
-                p2_time: ((nb::block!(self.serial.read())? as u16) << 8)
-                    | nb::block!(self.serial.read())? as u16,
+            0xc4 => Ok(SerialMsg::Sync {
+                p1_time: self.read_u32(),
+                p2_time: self.read_u32(),
             }),
-            0x05 => Ok(SerialMsg::Pause {
-                time: ((nb::block!(self.serial.read())? as u16) << 8)
-                    | nb::block!(self.serial.read())? as u16,
+            0xc5 => Ok(SerialMsg::Pause {
+                time: self.read_u32(),
             }),
             _ => {
                 // Huh? Malformed message, this isn't good, ignore the message
@@ -120,12 +157,20 @@ impl<USART: UsartOps<Atmega, RX, TX>, RX, TX> SerialHandler<USART, RX, TX> {
     pub fn read(&mut self) -> nb::Result<SerialMsg, void::Void> {
         let msg = self.raw_read()?;
         match msg {
-            SerialMsg::Handshake => {
+            SerialMsg::Handshake { mode } => {
                 self.connected = true;
-                self.write(SerialMsg::HandshakeResponse)?;
+                let selected_mode = match mode {
+                    0x0000 => 0x0002, // if we decide, make them a slave
+                    0x0001 => 0x0001, // syncing
+                    0x0002 => 0x0000, // if we're a slave, it's not supported
+                    0x0003 => 0x0003, // we're master
+                    _ => 0x0000,      // unsupported value
+                };
+                self.write(SerialMsg::HandshakeResponse { selected_mode });
                 Err(nb::Error::WouldBlock)
             }
-            SerialMsg::HandshakeResponse => {
+            SerialMsg::HandshakeResponse { selected_mode: _ } => {
+                // hopefully selected_mode is ok. we don't have the resources to check
                 self.connected = true;
                 Err(nb::Error::WouldBlock)
             }
@@ -137,7 +182,7 @@ impl<USART: UsartOps<Atmega, RX, TX>, RX, TX> SerialHandler<USART, RX, TX> {
         if let None = self.wait_start {
             self.connected = false;
             self.wait_start = Some(millis());
-            self.write(SerialMsg::Handshake)?;
+            self.write(SerialMsg::Handshake { mode: 0x0002 });
         }
         let wait_start = self.wait_start.unwrap();
         match self.read() {