From 389cb2d653591ed1d34029216172d591dc59ee60 Mon Sep 17 00:00:00 2001
From: vegano1 <brayan.almonte@gmail.com>
Date: Thu, 18 Jan 2024 11:30:02 -0500
Subject: [PATCH 1/3] feat(hepa-uv): add a task to handle the UV Ballast

---
 hepa-uv/core/tasks.cpp           | 13 ++++-
 include/hepa-uv/core/tasks.hpp   | 11 +++-
 include/hepa-uv/core/uv_task.hpp | 90 ++++++++++++++++++++++++++++++++
 3 files changed, 112 insertions(+), 2 deletions(-)
 create mode 100644 include/hepa-uv/core/uv_task.hpp

diff --git a/hepa-uv/core/tasks.cpp b/hepa-uv/core/tasks.cpp
index 2ac648d19..5ff086ffa 100644
--- a/hepa-uv/core/tasks.cpp
+++ b/hepa-uv/core/tasks.cpp
@@ -17,6 +17,9 @@ static auto queues = hepauv_tasks::QueueClient{can::ids::NodeId::hepa_uv};
 static auto hepa_task_builder =
     freertos_task::TaskStarter<512, hepa_task::HepaTask>{};
 
+static auto uv_task_builder =
+    freertos_task::TaskStarter<512, uv_task::UVTask>{};
+
 /**
  * Start hepa_uv tasks.
  */
@@ -27,22 +30,30 @@ void hepauv_tasks::start_tasks(
     can_task::start_reader(can_bus);
 
     auto& hepa_task = hepa_task_builder.start(5, "hepa_fan", gpio_drive_pins);
+    auto& uv_task = uv_task_builder.start(5, "uv_ballast", gpio_drive_pins);
 
     tasks.hepa_task_handler = &hepa_task;
+    tasks.uv_task_handler = &uv_task;
     tasks.can_writer = &can_writer;
 
     queues.set_queue(&can_writer.get_queue());
     queues.hepa_queue = &hepa_task.get_queue();
+    queues.uv_queue = &uv_task.get_queue();
 }
 
 hepauv_tasks::QueueClient::QueueClient(can::ids::NodeId this_fw)
     : can::message_writer::MessageWriter{this_fw} {}
 
-void hepauv_tasks::QueueClient::send_interrupt_message(
+void hepauv_tasks::QueueClient::send_hepa_message(
     const hepa_task::TaskMessage& m) {
     hepa_queue->try_write(m);
 }
 
+void hepauv_tasks::QueueClient::send_uv_message(
+    const uv_task::TaskMessage& m) {
+    uv_queue->try_write(m);
+}
+
 /**
  * Access to the tasks singleton
  * @return
diff --git a/include/hepa-uv/core/tasks.hpp b/include/hepa-uv/core/tasks.hpp
index d9f633cd4..8c3001b37 100644
--- a/include/hepa-uv/core/tasks.hpp
+++ b/include/hepa-uv/core/tasks.hpp
@@ -2,6 +2,7 @@
 #include "can/core/message_writer.hpp"
 #include "common/core/freertos_timer.hpp"
 #include "hepa-uv/core/hepa_task.hpp"
+#include "hepa-uv/core/uv_task.hpp"
 #include "hepa-uv/firmware/gpio_drive_hardware.hpp"
 
 namespace hepauv_tasks {
@@ -18,10 +19,14 @@ void start_tasks(can::bus::CanBus& can_bus,
 struct QueueClient : can::message_writer::MessageWriter {
     QueueClient(can::ids::NodeId this_fw);
 
-    void send_interrupt_message(const hepa_task::TaskMessage& m);
+    void send_hepa_message(const hepa_task::TaskMessage& m);
+    void send_uv_message(const hepa_task::TaskMessage& m);
 
     freertos_message_queue::FreeRTOSMessageQueue<hepa_task::TaskMessage>*
         hepa_queue{nullptr};
+
+    freertos_message_queue::FreeRTOSMessageQueue<uv_task::TaskMessage>*
+        uv_queue{nullptr};
 };
 
 /**
@@ -33,6 +38,10 @@ struct AllTask {
 
     hepa_task::HepaTask<freertos_message_queue::FreeRTOSMessageQueue>*
         hepa_task_handler{nullptr};
+
+    uv_task::UVTask<freertos_message_queue::FreeRTOSMessageQueue>*
+        uv_task_handler{nullptr};
+
 };
 
 /**
diff --git a/include/hepa-uv/core/uv_task.hpp b/include/hepa-uv/core/uv_task.hpp
new file mode 100644
index 000000000..30915ee53
--- /dev/null
+++ b/include/hepa-uv/core/uv_task.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+#include "can/core/ids.hpp"
+#include "common/core/bit_utils.hpp"
+#include "common/core/logging.h"
+#include "common/core/message_queue.hpp"
+#include "hepa-uv/firmware/gpio_drive_hardware.hpp"
+#include "messages.hpp"
+
+namespace uv_task {
+
+using TaskMessage = interrupt_task_messages::TaskMessage;
+
+class UVMessageHandler {
+  public:
+    explicit UVMessageHandler(gpio_drive_hardware::GpioDrivePins &drive_pins)
+        : drive_pins{drive_pins} {}
+    UVMessageHandler(const UVMessageHandler &) = delete;
+    UVMessageHandler(const UVMessageHandler &&) = delete;
+    auto operator=(const UVMessageHandler &) -> UVMessageHandler & = delete;
+    auto operator=(const UVMessageHandler &&)
+        -> UVMessageHandler && = delete;
+    ~UVMessageHandler() {}
+
+    void handle_message(const TaskMessage &m) {
+        std::visit([this](auto o) { this->visit(o); }, m);
+    }
+
+  private:
+    void visit(const std::monostate &) {}
+
+    // Handle GPIO EXTI Interrupts here
+    void visit(const interrupt_task_messages::GPIOInterruptChanged &m) {
+        if (m.pin == drive_pins.uv_push_button.pin) {
+            uv_push_button = !uv_push_button;
+            // handle state changes here
+            if (uv_push_button) {
+                gpio::set(drive_pins.uv_on_off);
+            } else {
+                gpio::reset(drive_pins.uv_on_off);
+            }
+        }
+
+        // TODO: send CAN message to host
+    }
+
+    // state tracking variables
+    // TODO: add reed, door_open, etc
+    bool uv_push_button = false;
+    bool uv_fan_on = false;
+
+    gpio_drive_hardware::GpioDrivePins &drive_pins;
+};
+
+/**
+ * The task type.
+ */
+template <template <class> class QueueImpl>
+requires MessageQueue<QueueImpl<TaskMessage>, TaskMessage>
+class UVTask {
+  public:
+    using Messages = TaskMessage;
+    using QueueType = QueueImpl<TaskMessage>;
+    UVTask(QueueType &queue) : queue{queue} {}
+    UVTask(const UVTask &c) = delete;
+    UVTask(const UVTask &&c) = delete;
+    auto operator=(const UVTask &c) = delete;
+    auto operator=(const UVTask &&c) = delete;
+    ~UVTask() = default;
+
+    /**
+     * Task entry point.
+     */
+    [[noreturn]] void operator()(
+        gpio_drive_hardware::GpioDrivePins *drive_pins) {
+        auto handler = UVMessageHandler{*drive_pins};
+        TaskMessage message{};
+        for (;;) {
+            if (queue.try_read(&message, queue.max_delay)) {
+                handler.handle_message(message);
+            }
+        }
+    }
+
+    [[nodiscard]] auto get_queue() const -> QueueType & { return queue; }
+
+  private:
+    QueueType &queue;
+};
+};  // namespace uv_task

From 96b5eb718a1f32f6c117ddc47d51d9278b9a763c Mon Sep 17 00:00:00 2001
From: vegano1 <brayan.almonte@gmail.com>
Date: Thu, 18 Jan 2024 14:37:14 -0500
Subject: [PATCH 2/3] feat(hepa-uv): add a task to handle the UV ballast state.

---
 hepa-uv/core/tasks.cpp             |  3 +-
 hepa-uv/firmware/main_rev1.cpp     | 12 ++++--
 include/hepa-uv/core/hepa_task.hpp |  7 +++-
 include/hepa-uv/core/tasks.hpp     |  1 -
 include/hepa-uv/core/uv_task.hpp   | 62 +++++++++++++++++++++++++-----
 5 files changed, 67 insertions(+), 18 deletions(-)

diff --git a/hepa-uv/core/tasks.cpp b/hepa-uv/core/tasks.cpp
index 5ff086ffa..7286336b8 100644
--- a/hepa-uv/core/tasks.cpp
+++ b/hepa-uv/core/tasks.cpp
@@ -49,8 +49,7 @@ void hepauv_tasks::QueueClient::send_hepa_message(
     hepa_queue->try_write(m);
 }
 
-void hepauv_tasks::QueueClient::send_uv_message(
-    const uv_task::TaskMessage& m) {
+void hepauv_tasks::QueueClient::send_uv_message(const uv_task::TaskMessage& m) {
     uv_queue->try_write(m);
 }
 
diff --git a/hepa-uv/firmware/main_rev1.cpp b/hepa-uv/firmware/main_rev1.cpp
index a2eb62525..4622ec289 100644
--- a/hepa-uv/firmware/main_rev1.cpp
+++ b/hepa-uv/firmware/main_rev1.cpp
@@ -91,7 +91,7 @@ static auto gpio_drive_pins = gpio_drive_hardware::GpioDrivePins{
         .pin = UV_ON_OFF_MCU_PIN,
         .active_setting = UV_ON_OFF_AS}};
 
-static auto& hepa_queue_client = hepauv_tasks::get_main_queues();
+static auto& hepauv_queues = hepauv_tasks::get_main_queues();
 
 extern "C" void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
     switch (GPIO_Pin) {
@@ -99,12 +99,16 @@ extern "C" void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
         case REED_SW_MCU_PIN:
         case HEPA_NO_MCU_PIN:
         case UV_NO_MCU_PIN:
-            if (hepa_queue_client.hepa_queue != nullptr) {
-                static_cast<void>(hepa_queue_client.hepa_queue->try_write_isr(
+            if (hepauv_queues.hepa_queue != nullptr) {
+                static_cast<void>(hepauv_queues.hepa_queue->try_write_isr(
+                    interrupt_task_messages::GPIOInterruptChanged{
+                        .pin = GPIO_Pin}));
+            }
+            if (hepauv_queues.uv_queue != nullptr) {
+                static_cast<void>(hepauv_queues.uv_queue->try_write_isr(
                     interrupt_task_messages::GPIOInterruptChanged{
                         .pin = GPIO_Pin}));
             }
-            // send to uv queue here
             break;
         default:
             break;
diff --git a/include/hepa-uv/core/hepa_task.hpp b/include/hepa-uv/core/hepa_task.hpp
index 413e02b99..bf9e5fb1a 100644
--- a/include/hepa-uv/core/hepa_task.hpp
+++ b/include/hepa-uv/core/hepa_task.hpp
@@ -15,7 +15,12 @@ using TaskMessage = interrupt_task_messages::TaskMessage;
 class HepaMessageHandler {
   public:
     explicit HepaMessageHandler(gpio_drive_hardware::GpioDrivePins &drive_pins)
-        : drive_pins{drive_pins} {}
+        : drive_pins{drive_pins} {
+        // get current state
+        hepa_push_button = gpio::is_set(drive_pins.hepa_push_button);
+        // turn off the HEPA fan
+        gpio::reset(drive_pins.hepa_on_off);
+    }
     HepaMessageHandler(const HepaMessageHandler &) = delete;
     HepaMessageHandler(const HepaMessageHandler &&) = delete;
     auto operator=(const HepaMessageHandler &) -> HepaMessageHandler & = delete;
diff --git a/include/hepa-uv/core/tasks.hpp b/include/hepa-uv/core/tasks.hpp
index 8c3001b37..bee8d3a0b 100644
--- a/include/hepa-uv/core/tasks.hpp
+++ b/include/hepa-uv/core/tasks.hpp
@@ -41,7 +41,6 @@ struct AllTask {
 
     uv_task::UVTask<freertos_message_queue::FreeRTOSMessageQueue>*
         uv_task_handler{nullptr};
-
 };
 
 /**
diff --git a/include/hepa-uv/core/uv_task.hpp b/include/hepa-uv/core/uv_task.hpp
index 30915ee53..73d8abd79 100644
--- a/include/hepa-uv/core/uv_task.hpp
+++ b/include/hepa-uv/core/uv_task.hpp
@@ -6,20 +6,33 @@
 #include "common/core/message_queue.hpp"
 #include "hepa-uv/firmware/gpio_drive_hardware.hpp"
 #include "messages.hpp"
+#include "ot_utils/freertos/freertos_timer.hpp"
 
 namespace uv_task {
 
+// How long to keep the UV light on in ms.
+static constexpr uint32_t DELAY_MS = 1000 * 60 * 15;  // 15 minutes
+
 using TaskMessage = interrupt_task_messages::TaskMessage;
 
 class UVMessageHandler {
   public:
     explicit UVMessageHandler(gpio_drive_hardware::GpioDrivePins &drive_pins)
-        : drive_pins{drive_pins} {}
+        : drive_pins{drive_pins},
+          _timer(
+              "UVTask", [ThisPtr = this] { ThisPtr->timer_callback(); },
+              DELAY_MS) {
+        // get current state
+        uv_push_button = gpio::is_set(drive_pins.uv_push_button);
+        door_closed = gpio::is_set(drive_pins.door_open);
+        reed_switch_set = gpio::is_set(drive_pins.reed_switch);
+        // turn off UV Ballast
+        gpio::reset(drive_pins.uv_on_off);
+    }
     UVMessageHandler(const UVMessageHandler &) = delete;
     UVMessageHandler(const UVMessageHandler &&) = delete;
     auto operator=(const UVMessageHandler &) -> UVMessageHandler & = delete;
-    auto operator=(const UVMessageHandler &&)
-        -> UVMessageHandler && = delete;
+    auto operator=(const UVMessageHandler &&) -> UVMessageHandler && = delete;
     ~UVMessageHandler() {}
 
     void handle_message(const TaskMessage &m) {
@@ -27,29 +40,58 @@ class UVMessageHandler {
     }
 
   private:
+    // call back to turn off the UV ballast
+    auto timer_callback() -> void {
+        gpio::reset(drive_pins.uv_on_off);
+        uv_push_button = false;
+        uv_fan_on = false;
+    }
+
     void visit(const std::monostate &) {}
 
     // Handle GPIO EXTI Interrupts here
     void visit(const interrupt_task_messages::GPIOInterruptChanged &m) {
+        if (m.pin == drive_pins.hepa_push_button.pin) {
+            // ignore hepa push button presses
+            return;
+        }
+
+        // update states
         if (m.pin == drive_pins.uv_push_button.pin) {
             uv_push_button = !uv_push_button;
-            // handle state changes here
-            if (uv_push_button) {
-                gpio::set(drive_pins.uv_on_off);
-            } else {
-                gpio::reset(drive_pins.uv_on_off);
-            }
+        } else if (m.pin == drive_pins.door_open.pin) {
+            door_closed = gpio::is_set(drive_pins.door_open);
+        } else if (m.pin == drive_pins.reed_switch.pin) {
+            reed_switch_set = gpio::is_set(drive_pins.reed_switch);
+        }
+
+        // reset push button state if the door is opened or the reed switch is
+        // not set
+        if (!door_closed || !reed_switch_set) uv_push_button = false;
+
+        // set the UV Ballast
+        if (door_closed && reed_switch_set && uv_push_button) {
+            gpio::set(drive_pins.uv_on_off);
+            // start the turn off timer
+            _timer.start();
+            uv_fan_on = true;
+        } else {
+            gpio::reset(drive_pins.uv_on_off);
+            _timer.stop();
+            uv_fan_on = false;
         }
 
         // TODO: send CAN message to host
     }
 
     // state tracking variables
-    // TODO: add reed, door_open, etc
+    bool door_closed = false;
+    bool reed_switch_set = false;
     bool uv_push_button = false;
     bool uv_fan_on = false;
 
     gpio_drive_hardware::GpioDrivePins &drive_pins;
+    ot_utils::freertos_timer::FreeRTOSTimer _timer;
 };
 
 /**

From 1b1997f1b7f9d4b371df30b97898fddc5e840677 Mon Sep 17 00:00:00 2001
From: vegano1 <brayan.almonte@gmail.com>
Date: Thu, 18 Jan 2024 15:30:31 -0500
Subject: [PATCH 3/3] cancel timer if already running

---
 include/hepa-uv/core/uv_task.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/hepa-uv/core/uv_task.hpp b/include/hepa-uv/core/uv_task.hpp
index 73d8abd79..0787b6fb0 100644
--- a/include/hepa-uv/core/uv_task.hpp
+++ b/include/hepa-uv/core/uv_task.hpp
@@ -73,11 +73,12 @@ class UVMessageHandler {
         if (door_closed && reed_switch_set && uv_push_button) {
             gpio::set(drive_pins.uv_on_off);
             // start the turn off timer
+            if (_timer.is_running()) _timer.stop();
             _timer.start();
             uv_fan_on = true;
         } else {
             gpio::reset(drive_pins.uv_on_off);
-            _timer.stop();
+            if (_timer.is_running()) _timer.stop();
             uv_fan_on = false;
         }