Remove Usage of Alarm Module in sleep_helper (#306)

Signed-off-by: Michael Pham <[email protected]>

Author: Mikefly123

circuitpython-workspaces/flight-software/src/pysquared/sleep_helper.py

@@ -6,9 +6,6 @@
 
 import time
 
-import alarm
-from alarm.time import TimeAlarm
-
 from .config.config import Config
 from .logger import Logger
 from .watchdog import Watchdog
@@ -19,7 +16,6 @@ class SleepHelper:
     Class responsible for sleeping the Satellite to conserve power.
 
     Attributes:
-        cubesat (Satellite): The Satellite object.
         logger (Logger): Logger instance for logging events and errors.
         watchdog (Watchdog): Watchdog instance for system safety.
         config (Config): Configuration object.
@@ -38,14 +34,15 @@ def __init__(self, logger: Logger, config: Config, watchdog: Watchdog) -> None:
         self.config: Config = config
         self.watchdog: Watchdog = watchdog
 
-    def safe_sleep(self, duration) -> None:
+    def safe_sleep(self, duration, watchdog_timeout=15) -> None:
         """
-        Puts the Satellite to sleep for a specified duration, in seconds.
+        Puts the Satellite to sleep for a specified duration, in seconds while still petting the watchdog at least every 15 seconds.
 
         Allows for a maximum sleep duration of the longest_allowable_sleep_time field specified in config
 
         Args:
             duration (int): Specified time, in seconds, to sleep the Satellite for.
+            watchdog_timeout (int): Time, in seconds, to wait before petting the watchdog. Default is 15 seconds.
         """
         # Ensure the duration does not exceed the longest allowable sleep time
         if duration > self.config.longest_allowable_sleep_time:
@@ -66,15 +63,9 @@ def safe_sleep(self, duration) -> None:
 
         # Sleep in increments to allow for watchdog to be pet
         while time.monotonic() < end_sleep_time:
-            # TODO(nateinaction): Replace the hardcoded watchdog timeout with a config value
-            watchdog_timeout = 15
-
             time_increment = min(end_sleep_time - time.monotonic(), watchdog_timeout)
 
-            time_alarm: TimeAlarm = TimeAlarm(
-                monotonic_time=time.monotonic() + time_increment
-            )
-            alarm.light_sleep_until_alarms(time_alarm)
+            time.sleep(time_increment)
 
             # Pet the watchdog on wake
             self.watchdog.pet()

cpython-workspaces/flight-software-unit-tests/src/unit-tests/test_sleep_helper.py

@@ -5,24 +5,14 @@
 of sleep duration limits.
 """
 
-import sys
 from unittest.mock import MagicMock, patch
 
 import pytest
 from pysquared.config.config import Config
 from pysquared.logger import Logger
+from pysquared.sleep_helper import SleepHelper
 from pysquared.watchdog import Watchdog
 
-# Create mock modules for alarm and alarm.time before importing SleepHelper
-mock_alarm = MagicMock()
-mock_time_alarm = MagicMock()
-sys.modules["alarm"] = mock_alarm
-sys.modules["alarm.time"] = MagicMock()
-sys.modules["alarm.time"].TimeAlarm = mock_time_alarm
-
-# Now we can import SleepHelper
-from pysquared.sleep_helper import SleepHelper  # noqa: E402
-
 
 @pytest.fixture
 def mock_logger() -> MagicMock:
@@ -88,31 +78,30 @@ def test_safe_sleep_within_limit(
         mock_logger: Mocked Logger instance.
         mock_watchdog: Mocked Watchdog instance.
     """
-    # Reset mocks
-    mock_alarm.reset_mock()
-    mock_time_alarm.reset_mock()
-
-    # Setup mock time to simulate a time sequence
-    mock_time.monotonic = MagicMock()
-    mock_time.monotonic.side_effect = [0.0, 0.0, 0.0, 0.0, 15.0]
+    # Setup mock time to simulate the while loop behavior
+    # The loop checks: while time.monotonic() < end_sleep_time
+    mock_time.monotonic.side_effect = [
+        0.0,  # Initial call for end_sleep_time calculation
+        0.0,  # First while loop check (0.0 < 15.0 = True)
+        0.0,  # min() calculation for time_increment
+        15.0,  # Second while loop check (15.0 < 15.0 = False, exit loop)
+    ]
+    mock_time.sleep = MagicMock()
 
     sleep_helper.safe_sleep(15)
 
-    # Verify the watchdog was pet
+    # Verify the watchdog was pet twice (once before loop, once after sleep)
     assert mock_watchdog.pet.call_count == 2
 
+    # Verify time.sleep was called with the correct increment
+    mock_time.sleep.assert_called_once_with(15.0)
+
     # Verify no warning was logged
     mock_logger.warning.assert_not_called()
 
     # Verify debug log was called
     mock_logger.debug.assert_called_once_with("Setting Safe Sleep Mode", duration=15)
 
-    # Verify TimeAlarm was created with correct parameters
-    mock_time_alarm.assert_called_once_with(monotonic_time=15.0)
-
-    # Verify light_sleep was called with the alarm
-    mock_alarm.light_sleep_until_alarms.assert_called_once()
-
 
 @patch("pysquared.sleep_helper.time")
 def test_safe_sleep_exceeds_limit(
@@ -131,18 +120,20 @@ def test_safe_sleep_exceeds_limit(
         mock_config: Mocked Config instance.
         mock_watchdog: Mocked Watchdog instance.
     """
-    # Reset mocks
-    mock_alarm.reset_mock()
-    mock_time_alarm.reset_mock()
-
-    # Setup mock time to simulate a time sequence
-    mock_time.monotonic.side_effect = [0.0, 0.0, 0.0, 0.0, 115.0]
+    # Setup mock time to simulate the while loop behavior with adjusted duration
+    mock_time.monotonic.side_effect = [
+        0.0,  # Initial call for end_sleep_time calculation
+        0.0,  # First while loop check (0.0 < 100.0 = True)
+        0.0,  # min() calculation for time_increment
+        100.0,  # Second while loop check (100.0 < 100.0 = False, exit loop)
+    ]
+    mock_time.sleep = MagicMock()
 
     # Requested duration exceeds the longest allowable sleep time (which is 100)
     sleep_helper.safe_sleep(150)
 
     # Verify the watchdog was pet
-    mock_watchdog.pet.assert_called()
+    assert mock_watchdog.pet.call_count == 2
 
     # Verify warning was logged
     mock_logger.warning.assert_called_once_with(
@@ -155,11 +146,8 @@ def test_safe_sleep_exceeds_limit(
     # Verify debug log was called with adjusted duration
     mock_logger.debug.assert_called_once_with("Setting Safe Sleep Mode", duration=100)
 
-    # Verify TimeAlarm was created with correct parameters using adjusted duration
-    mock_time_alarm.assert_called_once_with(monotonic_time=15.0)
-
-    # Verify light_sleep was called with the alarm
-    mock_alarm.light_sleep_until_alarms.assert_called_once()
+    # Verify time.sleep was called with the adjusted duration
+    mock_time.sleep.assert_called_once_with(15)
 
 
 @patch("pysquared.sleep_helper.time")
@@ -175,37 +163,71 @@ def test_safe_sleep_multiple_watchdog_pets(
         sleep_helper: SleepHelper instance for testing.
         mock_watchdog: Mocked Watchdog instance.
     """
-    # Reset mocks
-    mock_alarm.reset_mock()
-    mock_time_alarm.reset_mock()
-
-    # Setup mock time to simulate a time sequence where we need multiple increments
+    # Setup mock time to simulate multiple sleep increments
     mock_time.monotonic.side_effect = [
-        0.0,
-        0.0,
-        0.0,
-        0.0,  # Initial
-        15.0,
-        15.0,
-        15.0,  # First loop
-        30.0,
-        30.0,
-        30.0,  # Second loop
-        35.0,  # Last check and exit loop
+        0.0,  # Initial call for end_sleep_time calculation
+        0.0,  # First while loop check (0.0 < 35.0 = True)
+        0.0,  # First min() calculation (35.0 - 0.0, 15) = 15.0
+        15.0,  # Second while loop check (15.0 < 35.0 = True)
+        15.0,  # Second min() calculation (35.0 - 15.0, 15) = 15.0
+        30.0,  # Third while loop check (30.0 < 35.0 = True)
+        30.0,  # Third min() calculation (35.0 - 30.0, 15) = 5.0
+        35.0,  # Fourth while loop check (35.0 < 35.0 = False, exit loop)
     ]
+    mock_time.sleep = MagicMock()
 
     # Call safe_sleep with a duration that will require multiple watchdog pets
     sleep_helper.safe_sleep(35)
 
-    # Verify watchdog was pet multiple times (once before sleeping + after each wake)
-    assert mock_watchdog.pet.call_count == 4  # Once before loop + three times in loop
+    # Verify watchdog was pet multiple times (once before loop + after each sleep)
+    assert (
+        mock_watchdog.pet.call_count == 4
+    )  # Once before loop + three times after each sleep
+
+    # Verify time.sleep was called multiple times with correct increments
+    expected_calls = [
+        ((15.0,),),  # First increment: 15 seconds
+        ((15.0,),),  # Second increment: 15 seconds
+        ((5.0,),),  # Third increment: 5 seconds (remaining time)
+    ]
+    assert mock_time.sleep.call_args_list == expected_calls
+
 
-    # Verify TimeAlarm was created correctly for each increment
-    mock_time_alarm.assert_any_call(monotonic_time=15.0)  # 0.0 + 15.0 (first increment)
-    mock_time_alarm.assert_any_call(
-        monotonic_time=30.0
-    )  # 15.0 + 15.0 (second increment)
-    mock_time_alarm.assert_any_call(monotonic_time=35.0)  # 30.0 + 5.0 (final increment)
+@patch("pysquared.sleep_helper.time")
+def test_safe_sleep_custom_watchdog_timeout(
+    mock_time: MagicMock,
+    sleep_helper: SleepHelper,
+    mock_watchdog: MagicMock,
+) -> None:
+    """Tests safe_sleep with custom watchdog timeout.
 
-    # Verify light_sleep was called multiple times
-    assert mock_alarm.light_sleep_until_alarms.call_count == 3
+    Args:
+        mock_time: Mocked time module.
+        sleep_helper: SleepHelper instance for testing.
+        mock_watchdog: Mocked Watchdog instance.
+    """
+    # Setup mock time to simulate behavior with custom timeout
+    mock_time.monotonic.side_effect = [
+        0.0,  # Initial call for end_sleep_time calculation
+        0.0,  # First while loop check (0.0 < 20.0 = True)
+        0.0,  # First min() calculation (20.0 - 0.0, 10) = 10.0
+        10.0,  # Second while loop check (10.0 < 20.0 = True)
+        10.0,  # Second min() calculation (20.0 - 10.0, 10) = 10.0
+        20.0,  # Third while loop check (20.0 < 20.0 = False, exit loop)
+    ]
+    mock_time.sleep = MagicMock()
+
+    # Call safe_sleep with custom watchdog timeout
+    sleep_helper.safe_sleep(20, watchdog_timeout=10)
+
+    # Verify watchdog was pet correct number of times
+    assert (
+        mock_watchdog.pet.call_count == 3
+    )  # Once before loop + twice after each sleep
+
+    # Verify time.sleep was called with custom timeout intervals
+    expected_calls = [
+        ((10.0,),),  # First increment: 10 seconds (custom timeout)
+        ((10.0,),),  # Second increment: 10 seconds (custom timeout)
+    ]
+    assert mock_time.sleep.call_args_list == expected_calls