ledmatrix: Change sleep only if state changed or should sleep

This means the software sleep control will work again. Hardware sleep
control won't override it.

See README for details.

Signed-off-by: Daniel Schaefer <dhs@frame.work>

Author: JohnAZoidberg

ledmatrix/README.md

@@ -184,3 +184,29 @@ run the stop command.
 ```sh
 inputmodule-control led-amtrix --stop-game
 ```
+
+## Sleep Behavior
+
+Currently sleeping means all LEDs and the LED controller are turned off.
+Transitions of sleep state slowly fade the LEDs on or off.
+
+Optionally the firmware can be configured, at build-time, to turn the LEDs
+on/off immediately. Or display "SLEEP" instead of turning the LEDs off, which
+is useful for debugging whether the device is sleeping or not powered.
+
+
+###### Changing Sleep State
+
+What can change the sleep state
+
+- Hardware triggers
+  - `SLEEP#` pin
+  - USB Suspend
+- Software Triggers
+  - Sleep/Wake Command via USB Serial
+
+Both of the hardware triggers change the sleep state if the transition from one state to another.
+For example, if USB suspends, the LED matrix turns off. If it resumes, the LEDs come back on.
+Same for the `SLEEP#` pin.
+
+The sleep/wake command always changes the state. But it can't be received when USB is suspended.

ledmatrix/src/main.rs

@@ -254,24 +254,45 @@ fn main() -> ! {
     }
 
     let mut usb_initialized = false;
-    let mut usb_suspended = true;
+    let mut usb_suspended = false;
+    let mut last_usb_suspended = usb_suspended;
+    let mut sleeping = false;
+    let mut last_host_sleep = sleep.is_low().unwrap();
 
     loop {
         if sleep_present {
             // Go to sleep if the host is sleeping
-            // Or if USB is suspended. Only if it was previously initialized,
-            // since the OS puts the device into suspend before it's fully
-            // initialized for the first time. But we don't want to show the
-            // sleep animation during startup.
-            let host_sleeping = sleep.is_low().unwrap() || (usb_suspended && usb_initialized);
-            handle_sleep(
-                host_sleeping,
-                &mut state,
-                &mut matrix,
-                &mut delay,
-                &mut led_enable,
-            );
+            let host_sleeping = sleep.is_low().unwrap();
+            let host_sleep_changed = host_sleeping != last_host_sleep;
+            // Change sleep state either if SLEEP# has changed
+            // Or if it currently sleeping. Don't change if not sleeping
+            // because then sleep is controlled by timing or by API.
+            if host_sleep_changed || host_sleeping {
+                sleeping = host_sleeping;
+            }
+            last_host_sleep = host_sleeping;
+        }
+
+        // Change sleep state either if SLEEP# has changed
+        // Or if it currently sleeping. Don't change if not sleeping
+        // because then sleep is controlled by timing or by API.
+        let usb_suspended_changed = usb_suspended != last_usb_suspended;
+        // Only if USB was previously initialized,
+        // since the OS puts the device into suspend before it's fully
+        // initialized for the first time. But we don't want to show the
+        // sleep animation during startup.
+        if usb_initialized && (usb_suspended_changed || usb_suspended) {
+            sleeping = usb_suspended;
         }
+        last_usb_suspended = usb_suspended;
+
+        handle_sleep(
+            sleeping,
+            &mut state,
+            &mut matrix,
+            &mut delay,
+            &mut led_enable,
+        );
 
         // Handle period display updates. Don't do it too often
         let render_again = timer.get_counter().ticks() > prev_timer + state.animation_period;
@@ -326,6 +347,7 @@ fn main() -> ! {
                     let random = get_random_byte(&rosc);
                     match (parse_command(count, &buf), &state.sleeping) {
                         (Some(Command::Sleep(go_sleeping)), _) => {
+                            sleeping = go_sleeping;
                             handle_sleep(
                                 go_sleeping,
                                 &mut state,