Merge pull request #203 from somakeit/Add-open-hours-states

Add open hours states

Author: sjefferson99

smibhid/README.md

@@ -90,12 +90,17 @@ Use existing space state buttons, lights, slack API wrapper and watchers as an e
 - Display drivers can be added by creating a new display driver module
   - Ensure the driver registers itself with the driver registry, use LCD1602 as an example
   - Import the new driver module in display.py
-  - Update the config.py file to cinlude the option for your new driver
+  - Update the config.py file to include the option for your new driver
 - UIState machine
   - A state machine exists and can be extended by various modules such as space_state to manage the state of the buttons and display output
   - The current state instance is held in hid.ui_state_instance
-  - Enter a new UI state by caling the transition_to() method on a UIstate instance and pass any arguments needed by that state
-  - You will need to pass any core objects needed by the base UIState class and apply using super() as normal. These are currently HID (for managing the current state instance) and SpaceState so that the open and close buttons are avaialble in all UIs with default space open/closed behaviour.
+  - Enter a new UI state by calling the transition_to() method on a UIstate instance and pass any arguments needed by that state
+  - You will need to pass any core objects needed by the base UIState class and apply using super() as normal. These are currently HID (for managing the current state instance) and SpaceState so that the open and close buttons are available in all UIs with default space open/closed behaviour.
+
+### UI State diagram
+The space state UI state machine is described in this diagram:
+
+![Space state UI state machine diagram](images/SMIBHID_UI_state_diagram.drawio.png)
 
 ## Version
 Ensure that the `HID` class version attribute is updated to match the version in `pyproject.toml`

smibhid/images/SMIBHID_UI_state_diagram.drawio.png

@@ -184,6 +184,18 @@ async def _async_busy_spinner(self, col: int, row: int) -> None:
                 self.printout(char)
                 await async_sleep(0.2)
 
+    def add_hours(self, open_for_hours: int) -> None:
+        """Display a screen for adding open for hours information."""
+        self.log.info(f"Adding hours screen: {open_for_hours}")
+        self.print_on_line(0, "Opening space")
+        self.print_on_line(1, f"for {open_for_hours} hours")
+
+    def cancelling(self) -> None:
+        """Display cancelling text."""
+        self.log.info("Cancelling")
+        self.print_on_line(0, "Cancelling")
+        self.print_on_line(1, "Please wait...")
+
     def _begin(self, lines: int) -> None:
         """Configure and set initial display output."""
         if (lines > 1):

smibhid/lib/LCD1602.py

@@ -80,3 +80,13 @@ def clear_busy_output(self) -> None:
         """Clear all screens from busy output."""
         self.log.info("Clearing all screens of busy output")
         self._execute_command("clear_busy_output")
+
+    def add_hours(self, open_for_hours: int) -> None:
+        """Display a screen for adding open for hours information."""
+        self.log.info("Adding hours screen")
+        self._execute_command("add_hours", open_for_hours)
+    
+    def cancelling(self) -> None:
+        """Display cancelling text."""
+        self.log.info("Cancelling")
+        self._execute_command("cancelling")

smibhid/lib/display.py

@@ -79,7 +79,6 @@ class StartUIState(UIState):
 
     def __init__(self, hid: HID, space_state: SpaceState) -> None:
         super().__init__(hid, space_state)
-        self.hid = hid
         self.display = self.hid.display
         self.version = self.hid.version
 

smibhid/lib/hid.py

@@ -2,6 +2,7 @@
 from lib.networking import WirelessNetwork
 from lib.ulogging import uLogger
 from lib.rfid.reader import RFIDReader
+from config import RFID_ENABLED
 
 class ModuleNotRegisteredError(Exception):
     """Exception raised when a required module is not registered."""
@@ -41,8 +42,8 @@ def get_wifi(self) -> WirelessNetwork:
             raise ModuleNotRegisteredError("WiFi")
         return self.wifi
 
-    def get_rfid(self) -> RFIDReader:
-        if not self.reader:
+    def get_rfid(self) -> RFIDReader | None:
+        if not self.reader and RFID_ENABLED:
             self.log.warn("RFID module not registered")
             raise ModuleNotRegisteredError("RFID")
         return self.reader

smibhid/lib/module_config.py

@@ -13,6 +13,7 @@
 from lib.ulogging import uLogger
 from lib.utils import StatusLED
 from lib.uistate import UIState
+from time import ticks_ms
 
 
 class SpaceState:
@@ -56,6 +57,7 @@ def __init__(self, module_config: ModuleConfig, hid: object) -> None:
             self.space_state_poll_frequency = 5
         self.state_check_error_open_led_flash_task = None
         self.state_check_error_closed_led_flash_task = None
+        self.last_button_press_ms = 0
         self.configure_error_handling()
 
     def configure_error_handling(self) -> None:
@@ -230,6 +232,7 @@ async def async_space_open_button_watcher(self) -> None:
         while True:
             await self.space_open_button_event.wait()
             self.space_open_button_event.clear()
+            self.last_button_press_ms = ticks_ms()
             await self.hid.ui_state_instance.async_on_space_open_button()
 
 
@@ -241,6 +244,7 @@ async def async_space_close_button_watcher(self) -> None:
         while True:
             await self.space_closed_button_event.wait()
             self.space_closed_button_event.clear()
+            self.last_button_press_ms = ticks_ms()
             await self.hid.ui_state_instance.async_on_space_closed_button()
 
     async def async_space_state_watcher(self) -> None:
@@ -266,10 +270,47 @@ async def task_wrapper_for_error_handling():
             finally:
                 await sleep(self.space_state_poll_frequency)
 
+class SpaceStateUIState(UIState):
+    """
+    Base class for space state UI state.
+    """
+    def __init__(self, hid: object, space_state: SpaceState) -> None:
+        super().__init__(hid, space_state)
+        self.open_for_hours = 0
+
+    def last_button_press_x_seconds_ago(self, x: int = 2) -> bool:
+        """
+        Check if the last button press was x seconds ago.
+        """
+        now = ticks_ms()
+        return now - self.space_state.last_button_press_ms > (x * 1000)
+    
+    def increment_open_for_hours_single_digit(self) -> None:
+        """
+        Increment the open for hours counter.
+        """
+        if self.open_for_hours < 9:
+            self.open_for_hours += 1
+        else:
+            self.open_for_hours = 0
+        
+        self.hid.display.add_hours(self.open_for_hours)
+    
+    async def _async_button_timeout_watcher(self) -> None:
+        """
+        Call open space with current open hours count if no button press for 2 seconds.
+        """
+        while not self.last_button_press_x_seconds_ago(2):
+            await sleep(0.1)
+
+        await self._async_open_space(self.open_for_hours) # TODO change this so it cancels if closed button pressed
+
 class OpenState(UIState):
     """
     UI state for open space state.
     """
+    def __init__(self, hid: object, space_state: SpaceState) -> None:
+        super().__init__(hid, space_state)
 
     async def async_on_space_closed_button(self) -> None:
         await super().async_on_space_closed_button()
@@ -281,20 +322,47 @@ class ClosedState(UIState):
     """
     UI state for closed space state.
     """
+    def __init__(self, hid: object, space_state: SpaceState) -> None:
+        super().__init__(hid, space_state)
 
     async def async_on_space_closed_button(self) -> None:
         self.log.info("Space is already closed")
 
     async def async_on_space_open_button(self) -> None:
-        await super().async_on_space_open_button()
+        self.log.info("Adding hours to open for hours counter")
+        self.hid.ui_state_instance.transition_to(AddingHoursState(self.hid, self.space_state))
 
 class NoneState(UIState):
     """
     UI state for unknown space state.
     """
-
+    def __init__(self, hid: object, space_state: SpaceState) -> None:
+        super().__init__(hid, space_state)
+    
     async def async_on_space_closed_button(self) -> None:
         await super().async_on_space_closed_button()
 
     async def async_on_space_open_button(self) -> None:
         await super().async_on_space_open_button()
+
+class AddingHoursState(SpaceStateUIState):
+    """
+    UI state for adding hours to the open for hours counter.
+    """
+    def __init__(self, hid: object, space_state: SpaceState) -> None:
+        super().__init__(hid, space_state)
+
+    def on_enter(self) -> None:
+        super().on_enter()
+        self.hid.display.add_hours(self.open_for_hours)
+        self.button_timeout_task = create_task(self._async_button_timeout_watcher())
+
+    async def async_on_space_closed_button(self) -> None:
+        self.hid.display.cancelling()
+        self.button_timeout_task.cancel()
+        await sleep(1)
+        self.space_state._set_space_output(CLOSED)
+        self.hid.ui_state_instance.transition_to(ClosedState(self.hid, self.space_state))
+
+    async def async_on_space_open_button(self) -> None:
+        self.increment_open_for_hours_single_digit()

smibhid/lib/space_state.py

@@ -35,10 +35,9 @@ def transition_to(self, state: 'UIState') -> None:
         self.hid.set_ui_state(state)
         state.on_enter()
 
-    async def async_on_space_closed_button(self) -> None:
+    async def _async_close_space(self) -> None:
         """
-        Default action for space closed button press.
-        Updates SMIB space state to closed regardless of current space state.
+        Default action for closing the space.
         """
         self.space_state.flash_task = create_task(self.space_state.space_closed_led.async_constant_flash(4))
         try:
@@ -53,14 +52,13 @@ async def async_on_space_closed_button(self) -> None:
             self.space_state.flash_task.cancel()
             self.space_state.space_closed_led.off()
 
-    async def async_on_space_open_button(self) -> None:
+    async def _async_open_space(self, open_for_hours: int = 0) -> None:
         """
-        Default action for space open button press.
-        Updates SMIB space state to open regardless of current space state.
+        Default action for opening the space.
         """
         self.space_state.flash_task = create_task(self.space_state.space_open_led.async_constant_flash(4))
         try:
-            await self.space_state.slack_api.async_space_open()
+            await self.space_state.slack_api.async_space_open(open_for_hours)
             self.space_state.flash_task.cancel()
             self.space_state.set_output_space_open()
             create_task(self.space_state.async_update_space_state_output())
@@ -70,3 +68,15 @@ async def async_on_space_open_button(self) -> None:
             )
             self.space_state.flash_task.cancel()
             self.space_state.space_open_led.off()
+    
+    async def async_on_space_closed_button(self) -> None:
+        """
+        Close space when space closed button pressed outside of space state UI.
+        """
+        await self._async_close_space()
+    
+    async def async_on_space_open_button(self) -> None:
+        """
+        Open space with no hours when when space open button pressed outside of space state UI.
+        """
+        await self._async_open_space()