Add API to get brightness, animate, sleep statuses

Signed-off-by: Daniel Schaefer <[email protected]>

Author: JohnAZoidberg

control.py

@@ -28,6 +28,7 @@
 ]
 DRAW_PATTERNS = ['off', 'on', 'foo']
 GREYSCALE_DEPTH = 32
+RESPONSE_SIZE = 32
 WIDTH = 9
 HEIGHT = 34
 
@@ -42,10 +43,16 @@ def main():
                         action="store_true")
     parser.add_argument('--sleep', help='Simulate the host going to sleep or waking up',
                         action=argparse.BooleanOptionalAction)
+    parser.add_argument('--is-sleeping', help='Check current sleep state',
+                        action='store_true')
     parser.add_argument("--brightness", help="Adjust the brightness. Value 0-255",
                         type=int)
+    parser.add_argument("--get-brightness", help="Get current brightness",
+                        action="store_true")
     parser.add_argument('--animate', action=argparse.BooleanOptionalAction,
                         help='Start/stop vertical scrolling')
+    parser.add_argument('--get-animate', action='store_true',
+                        help='Check if currently animating')
     parser.add_argument("--pattern", help='Display a pattern',
                         type=str, choices=PATTERNS)
     parser.add_argument("--image", help="Display a PNG or GIF image in black and white only)",
@@ -88,11 +95,19 @@ def main():
     elif args.sleep is not None:
         command = FWK_MAGIC + [0x03, args.sleep]
         send_command(command)
+    elif args.is_sleeping:
+        command = FWK_MAGIC + [0x03]
+        res = send_command(command, with_response=True)
+        sleeping = bool(res[0])
+        print(f"Currently sleeping: {sleeping}")
     elif args.brightness is not None:
         if args.brightness > 255 or args.brightness < 0:
             print("Brightness must be 0-255")
             sys.exit(1)
         brightness(args.brightness)
+    elif args.get_brightness:
+        br = get_brightness()
+        print(f"Current brightness: {br}")
     elif args.percentage is not None:
         if args.percentage > 100 or args.percentage < 0:
             print("Percentage must be 0-100")
@@ -102,6 +117,9 @@ def main():
         pattern(args.pattern)
     elif args.animate is not None:
         animate(args.animate)
+    elif args.get_animate:
+        animating = get_animate()
+        print(f"Currently animating: {animating}")
     elif args.panic:
         command = FWK_MAGIC + [0x05, 0x00]
         send_command(command)
@@ -154,13 +172,29 @@ def brightness(b: int):
     send_command(command)
 
 
+def get_brightness():
+    """Adjust the brightness scaling of the entire screen.
+    """
+    command = FWK_MAGIC + [0x00]
+    res = send_command(command, with_response=True)
+    return int(res[0])
+
+
 def animate(b: bool):
     """Tell the firmware to start/stop animation.
     Scrolls the currently saved grid vertically down."""
     command = FWK_MAGIC + [0x04, b]
     send_command(command)
 
 
+def get_animate():
+    """Tell the firmware to start/stop animation.
+    Scrolls the currently saved grid vertically down."""
+    command = FWK_MAGIC + [0x04]
+    res = send_command(command, with_response=True)
+    return bool(res[0])
+
+
 def image_bl(image_file):
     """Display an image in black and white
     Confirmed working with PNG and GIF.
@@ -600,14 +634,19 @@ def clock():
         time.sleep(1)
 
 
-def send_command(command):
+def send_command(command, with_response=False):
     """Send a command to the device.
     Opens new serial connection every time"""
     # print(f"Sending command: {command}")
     global SERIAL_DEV
     with serial.Serial(SERIAL_DEV, 115200) as s:
         s.write(command)
 
+        if with_response:
+            res = s.read(RESPONSE_SIZE)
+            #print(f"Received: {res}")
+            return res
+
 
 def send_serial(s, command):
     """Send serial command by using existing serial connection"""

src/bin/ledmatrix.rs

@@ -265,21 +265,32 @@ fn main() -> ! {
                     // Do nothing
                 }
                 Ok(count) => {
-                    if let Some(command) = parse_command(count, &buf) {
-                        if let Command::Sleep(go_sleeping) = command {
+                    match (parse_command(count, &buf), &state.sleeping) {
+                        (Some(Command::Sleep(go_sleeping)), _) => {
                             handle_sleep(
                                 go_sleeping,
                                 &mut state,
                                 &mut matrix,
                                 &mut delay,
                                 &mut led_enable,
                             );
-                        } else if let SleepState::Awake = state.sleeping {
+                        }
+                        (Some(c @ Command::BootloaderReset), _)
+                        | (Some(c @ Command::IsSleeping), _) => {
+                            if let Some(response) = handle_command(&c, &mut state, &mut matrix) {
+                                let _ = serial.write(&response);
+                            };
+                        }
+                        (Some(command), SleepState::Awake) => {
                             // While sleeping no command is handled, except waking up
-                            handle_command(&command, &mut state, &mut matrix);
+                            if let Some(response) =
+                                handle_command(&command, &mut state, &mut matrix)
+                            {
+                                let _ = serial.write(&response);
+                            };
+                            fill_grid_pixels(&state.grid, &mut matrix);
                         }
-
-                        fill_grid_pixels(&state.grid, &mut matrix);
+                        _ => {}
                     }
                 }
             }

src/control.rs

@@ -44,8 +44,10 @@ pub enum PatternVals {
 
 // TODO: Reduce size for modules that don't require other commands
 pub enum Command {
+    /// Get current brightness scaling
+    GetBrightness,
     /// Set brightness scaling
-    Brightness(u8),
+    SetBrightness(u8),
     /// Display pre-programmed pattern
     Pattern(PatternVals),
     /// Reset into bootloader
@@ -54,8 +56,10 @@ pub enum Command {
     Percentage(u8),
     /// Go to sleepe or wake up
     Sleep(bool),
+    IsSleeping,
     /// Start/stop animation (vertical scrolling)
-    Animate(bool),
+    SetAnimate(bool),
+    GetAnimate,
     /// Panic. Just to test what happens
     Panic,
     /// Draw black/white on the grid
@@ -74,17 +78,21 @@ pub fn parse_command(count: usize, buf: &[u8]) -> Option<Command> {
     }
 
     // Parse the generic commands common to all modules
-    if count >= 4 && buf[0] == 0x32 && buf[1] == 0xAC {
+    if count >= 3 && buf[0] == 0x32 && buf[1] == 0xAC {
         let command = buf[2];
-        let arg = buf[3];
+        let arg = if count <= 3 { None } else { Some(buf[3]) };
 
         //let mut text: String<64> = String::new();
         //writeln!(&mut text, "Command: {command}, arg: {arg}").unwrap();
         //let _ = serial.write(text.as_bytes());
 
         match command {
             0x02 => Some(Command::BootloaderReset),
-            0x03 => Some(Command::Sleep(arg == 1)),
+            0x03 => Some(if let Some(go_to_sleep) = arg {
+                Command::Sleep(go_to_sleep == 1)
+            } else {
+                Command::IsSleeping
+            }),
             0x05 => Some(Command::Panic),
             _ => None, //Some(Command::Unknown),
         }
@@ -95,30 +103,39 @@ pub fn parse_command(count: usize, buf: &[u8]) -> Option<Command> {
 
 #[cfg(feature = "ledmatrix")]
 pub fn parse_module_command(count: usize, buf: &[u8]) -> Option<Command> {
-    if count >= 4 && buf[0] == 0x32 && buf[1] == 0xAC {
+    if count >= 3 && buf[0] == 0x32 && buf[1] == 0xAC {
         let command = buf[2];
-        let arg = buf[3];
+        let arg = if count <= 3 { None } else { Some(buf[3]) };
 
         match command {
-            0x00 => Some(Command::Brightness(arg)),
+            0x00 => Some(if let Some(brightness) = arg {
+                Command::SetBrightness(brightness)
+            } else {
+                Command::GetBrightness
+            }),
             0x01 => match arg {
-                0x00 => {
+                Some(0x00) => {
                     if count >= 5 {
                         Some(Command::Percentage(buf[4]))
                     } else {
                         None
                     }
                 }
-                0x01 => Some(Command::Pattern(PatternVals::Gradient)),
-                0x02 => Some(Command::Pattern(PatternVals::DoubleGradient)),
-                0x03 => Some(Command::Pattern(PatternVals::DisplayLotus)),
-                0x04 => Some(Command::Pattern(PatternVals::ZigZag)),
-                0x05 => Some(Command::Pattern(PatternVals::FullBrightness)),
-                0x06 => Some(Command::Pattern(PatternVals::DisplayPanic)),
-                0x07 => Some(Command::Pattern(PatternVals::DisplayLotus2)),
-                _ => None,
+                Some(0x01) => Some(Command::Pattern(PatternVals::Gradient)),
+                Some(0x02) => Some(Command::Pattern(PatternVals::DoubleGradient)),
+                Some(0x03) => Some(Command::Pattern(PatternVals::DisplayLotus)),
+                Some(0x04) => Some(Command::Pattern(PatternVals::ZigZag)),
+                Some(0x05) => Some(Command::Pattern(PatternVals::FullBrightness)),
+                Some(0x06) => Some(Command::Pattern(PatternVals::DisplayPanic)),
+                Some(0x07) => Some(Command::Pattern(PatternVals::DisplayLotus2)),
+                Some(_) => None,
+                None => None,
             },
-            0x04 => Some(Command::Animate(arg == 1)),
+            0x04 => Some(if let Some(run_animation) = arg {
+                Command::SetAnimate(run_animation == 1)
+            } else {
+                Command::GetAnimate
+            }),
             0x06 => {
                 if count >= 3 + DRAW_BYTES {
                     let mut bytes = [0; DRAW_BYTES];
@@ -194,9 +211,14 @@ pub fn handle_generic_command(command: &Command) {
 }
 
 #[cfg(feature = "ledmatrix")]
-pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) {
+pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) -> Option<[u8; 32]> {
     match command {
-        Command::Brightness(br) => {
+        Command::GetBrightness => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = state.brightness;
+            return Some(response);
+        }
+        Command::SetBrightness(br) => {
             //let _ = serial.write("Brightness".as_bytes());
             state.brightness = *br;
             matrix
@@ -226,7 +248,12 @@ pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) {
                 _ => {}
             }
         }
-        Command::Animate(a) => state.animate = *a,
+        Command::SetAnimate(a) => state.animate = *a,
+        Command::GetAnimate => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = state.animate as u8;
+            return Some(response);
+        }
         Command::Draw(vals) => state.grid = draw(vals),
         Command::StageGreyCol(col, vals) => {
             draw_grey_col(&mut state.col_buffer, *col, vals);
@@ -237,8 +264,19 @@ pub fn handle_command(command: &Command, state: &mut State, matrix: &mut Foo) {
             // Zero the old staging buffer, just for good measure.
             state.col_buffer = percentage(0);
         }
+        // TODO: Move to handle_generic_command
+        Command::IsSleeping => {
+            let mut response: [u8; 32] = [0; 32];
+            response[0] = match state.sleeping {
+                SleepState::Sleeping(_) => 1,
+                SleepState::Awake => 0,
+            };
+            return Some(response);
+        }
+        // TODO: Make it return something
         _ => handle_generic_command(command),
     }
+    None
 }
 
 #[cfg(feature = "b1display")]