[#108] Update watchdog_pet() (#189)

Co-authored-by: SSL-Rey <[email protected]>

Author: yudataguy

lib/pysquared/pysquared.py

@@ -8,6 +8,7 @@
 """
 
 # Common CircuitPython Libs
+import asyncio  # Add asyncio import
 import sys
 import time
 from collections import OrderedDict
@@ -577,11 +578,38 @@ def date(self, ymdw: tuple[int, int, int, int]) -> None:
     """
 
     def watchdog_pet(self) -> None:
+        """Pet the watchdog timer"""
+        self.logger.debug("Petting watchdog")
         self.watchdog_pin.value = True
         time.sleep(0.01)
         self.watchdog_pin.value = False
 
+    async def _watchdog_pet_task(self) -> None:
+        """Async task to continuously pet the watchdog"""
+        self.logger.info("Starting watchdog petting background task")
+        while self.hardware.get("WDT", False):
+            self.watchdog_pet()
+            await asyncio.sleep(1.0)  # Pet watchdog every second
+        self.logger.info("Watchdog petting task stopped")
+
+    def start_watchdog_background_task(self) -> None:
+        """Start the watchdog petting as a true background task using asyncio"""
+        self._last_watchdog_pet = time.monotonic()
+        self.hardware["WDT"] = True
+        # Create and schedule the task but don't wait for it
+        asyncio.create_task(self._watchdog_pet_task())
+        self.logger.info("Watchdog background task created")
+
+    def check_watchdog(self) -> None:
+        """
+        Legacy method maintained for compatibility
+        The actual petting is now handled by the background task
+        """
+        pass  # No-op as this is now handled by the async task
+
     def check_reboot(self) -> None:
+        """Check if system needs to be rebooted"""
+        # No need to check watchdog anymore as it's handled by the background task
         self.UPTIME: int = self.get_system_uptime
         self.logger.debug("Current up time stat:", uptime=self.UPTIME)
         if self.UPTIME > self.reboot_time:

main.py

@@ -8,7 +8,7 @@
 Published: Nov 19, 2024
 """
 
-import gc
+import asyncio
 import time
 
 import digitalio
@@ -53,7 +53,10 @@
     config: Config = Config("config.json")
 
     c = pysquared.Satellite(config, logger, __version__)
-    c.watchdog_pet()
+
+    # Start the watchdog background task
+    c.start_watchdog_background_task()
+
     sleep_helper = SleepHelper(c, logger)
 
     radio_manager = RFM9xManager(
@@ -69,109 +72,107 @@
 
     f = functions.functions(c, logger, config, sleep_helper, radio_manager)
 
-    def initial_boot():
-        c.watchdog_pet()
+    async def initial_boot():
         f.beacon()
-        c.watchdog_pet()
         f.listen()
-        c.watchdog_pet()
-
-    try:
-        c.boot_count.increment()
 
-        logger.info(
-            "FC Board Stats",
-            bytes_remaining=gc.mem_free(),
-            boot_number=c.boot_count.get(),
-        )
-
-        initial_boot()
-
-    except Exception as e:
-        logger.error("Error in Boot Sequence", e)
+    async def critical_power_operations():
+        await initial_boot()
+        # Convert blocking operation to a non-blocking one using run_in_executor
+        # Since this is a blocking function that will likely put the device to sleep,
+        # we accept that this will block the event loop as intended
+        logger.info("Entering long hibernation (this will block the event loop)")
+        sleep_helper.long_hibernate()
+        logger.info("Woke from long hibernation")
 
-    finally:
-        pass
+    async def minimum_power_operations():
+        await initial_boot()
+        # Same as above - this is a blocking operation by design
+        logger.info("Entering short hibernation (this will block the event loop)")
+        sleep_helper.short_hibernate()
+        logger.info("Woke from short hibernation")
 
-    def send_imu_data():
+    async def send_imu_data():
         logger.info("Looking to get imu data...")
         IMUData = []
-        c.watchdog_pet()
-        logger.info("IMU has baton")
         IMUData = f.get_imu_data()
-        c.watchdog_pet()
         f.send(IMUData)
 
-    def main():
+    async def main():
         f.beacon()
-
         f.listen_loiter()
-
         f.state_of_health()
-
         f.listen_loiter()
-
         f.all_face_data()
-        c.watchdog_pet()
         f.send_face()
-
         f.listen_loiter()
-
-        send_imu_data()
-
+        await send_imu_data()
         f.listen_loiter()
-
         f.joke()
-
         f.listen_loiter()
 
-    def critical_power_operations():
-        initial_boot()
-        c.watchdog_pet()
-
-        sleep_helper.long_hibernate()
-
-    def minimum_power_operations():
-        initial_boot()
-        c.watchdog_pet()
-
-        sleep_helper.short_hibernate()
-
     ######################### MAIN LOOP ##############################
+    async def main_loop():
+        """Async main loop that runs alongside the watchdog task"""
+        try:
+            while True:
+                # L0 automatic tasks no matter the battery level
+                c.check_reboot()  # Now this only checks for reboot conditions
+
+                if c.power_mode == "critical":
+                    c.rgb = (0, 0, 0)
+                    await critical_power_operations()
+
+                elif c.power_mode == "minimum":
+                    c.rgb = (255, 0, 0)
+                    await minimum_power_operations()
+
+                elif c.power_mode == "normal":
+                    c.rgb = (255, 255, 0)
+                    await main()
+
+                elif c.power_mode == "maximum":
+                    c.rgb = (0, 255, 0)
+                    await main()
+
+                else:
+                    f.listen()
+
+                # Small yield to allow other tasks to run
+                await asyncio.sleep(0.1)
+
+        except Exception as e:
+            logger.critical("Critical in Main Loop", e)
+            time.sleep(10)
+            microcontroller.on_next_reset(microcontroller.RunMode.NORMAL)
+            microcontroller.reset()
+        finally:
+            logger.info("Going Neutral!")
+            c.rgb = (0, 0, 0)
+            c.hardware["WDT"] = False
+
+    # Set up the asyncio event loop
+    async def run_tasks():
+        # The watchdog task is already started by c.start_watchdog_background_task()
+        # Just run the main loop as a task
+        main_task = asyncio.create_task(main_loop())
+
+        try:
+            # Wait for the main task to complete (it should run forever)
+            await main_task
+        except asyncio.CancelledError:
+            logger.info("Main task was cancelled")
+        except Exception as e:
+            logger.critical("Error in run_tasks", e)
+            raise
+
+    # Run the asyncio event loop
     try:
-        while True:
-            # L0 automatic tasks no matter the battery level
-            c.check_reboot()
-
-            if c.power_mode == "critical":
-                c.rgb = (0, 0, 0)
-                critical_power_operations()
-
-            elif c.power_mode == "minimum":
-                c.rgb = (255, 0, 0)
-                minimum_power_operations()
-
-            elif c.power_mode == "normal":
-                c.rgb = (255, 255, 0)
-                main()
-
-            elif c.power_mode == "maximum":
-                c.rgb = (0, 255, 0)
-                main()
-
-            else:
-                f.listen()
-
+        asyncio.run(run_tasks())
     except Exception as e:
-        logger.critical("Critical in Main Loop", e)
-        time.sleep(10)
+        logger.critical("Error in asyncio.run", e)
         microcontroller.on_next_reset(microcontroller.RunMode.NORMAL)
         microcontroller.reset()
-    finally:
-        logger.info("Going Neutral!")
-
-        c.rgb = (0, 0, 0)
-        c.hardware["WDT"] = False
 
 except Exception as e:
     logger.critical("An exception occured within main.py", e)