add pressure_task and pump_task skeletons

Author: vegano1

stm32-modules/include/vacuum-module/firmware/firmware_tasks.hpp

@@ -23,4 +23,7 @@ constexpr uint8_t UI_TASK_PRIORITY = 1;
 
 constexpr size_t PRESSURE_STACK_SIZE = 256;
 constexpr uint8_t PRESSURE_TASK_PRIORITY = 1;
+
+constexpr size_t PUMP_STACK_SIZE = 256;
+constexpr uint8_t PUMP_TASK_PRIORITY = 1;
 }  // namespace tasks

stm32-modules/include/vacuum-module/firmware/freertos_tasks.hpp

@@ -28,3 +28,9 @@ namespace pressure_control_task {
 auto run(tasks::FirmwareTasks::QueueAggregator* aggregator,
          i2c::hardware::I2C* i2c_comms) -> void;
 }  // namespace pressure_control_task
+
+namespace pump_control_task {
+// Actual function that runs in the task
+auto run(tasks::FirmwareTasks::QueueAggregator* aggregator,
+         i2c::hardware::I2C* i2c_comms) -> void;
+}  // namespace pump_control_task

stm32-modules/include/vacuum-module/firmware/pump_policy.hpp

@@ -13,7 +13,8 @@ class PumpPolicy {
     auto stop_pump_motor() -> bool;
     auto set_pump_duty_cycle(uint16_t duty) -> void;
     auto get_pump_duty_cycle() -> uint16_t;
-    auto enable_pump_tach() -> bool;
+    auto enable_pump_tach(bool enable) -> bool;
     auto get_pump_rpm() -> float;
+    auto sleep_ms(uint32_t ms) -> void;
 };
 }  // namespace pump_policy

stm32-modules/include/vacuum-module/vacuum-module/lps22df.hpp

@@ -6,6 +6,7 @@
 
 namespace lps22df {
 
+
 template <typename P>
 concept LPS22DFPolicy = requires(P p, uint16_t dev_addr, uint16_t reg,
                                  uint16_t size, uint8_t* data) {
@@ -20,6 +21,7 @@ class LPS222DF {
             _policy = policy;
         }
     }
+
 };
 
-}  // namespace lps22df
+}  // namespace lps22df

stm32-modules/include/vacuum-module/vacuum-module/messages.hpp

@@ -110,6 +110,18 @@ struct SetStatusBarStateMessage {
     std::optional<float> power = std::nullopt;
 };
 
+struct SetTargetPressureMessage {
+    uint32_t id =  0;
+    bool from_host = false;
+    uint32_t pressure_setpoint = 0;
+};
+
+struct SetTargetRPMMessage {
+    uint32_t id =  0;
+    bool from_host = false;
+    uint32_t rpm_setpoint = 0;
+};
+
 using HostCommsMessage =
     ::std::variant<std::monostate, IncomingMessageFromHost, ForceUSBDisconnect,
                    ErrorMessage, AcknowledgePrevious, GetSystemInfoResponse,
@@ -122,6 +134,8 @@ using SystemMessage =
 
 using UIMessage = ::std::variant<std::monostate, SetStatusBarStateMessage>;
 
-using PressureMessage = ::std::variant<std::monostate>;
+using PressureMessage = ::std::variant<std::monostate, SetTargetPressureMessage>;
+
+using PumpMessage = ::std::variant<std::monostate, SetTargetRPMMessage>;
 
 };  // namespace messages

stm32-modules/include/vacuum-module/vacuum-module/pressure_task.hpp

@@ -88,6 +88,12 @@ class PressureTask {
         static_cast<void>(policy);
     }
 
+    template <PressureControlPolicy Policy>
+    auto visit_message(const messages::SetTargetPressureMessage& m, Policy& policy) -> void {
+        static_cast<void>(m);
+        static_cast<void>(policy);
+    }
+
     Queue& _message_queue;
     Aggregator* _task_registry;
     bool _initialized{false};

stm32-modules/include/vacuum-module/vacuum-module/pump_task.hpp

@@ -0,0 +1,102 @@
+#pragma once
+#include <cmath>
+#include <cstdint>
+
+#include "core/ack_cache.hpp"
+#include "core/queue_aggregator.hpp"
+#include "core/version.hpp"
+#include "firmware/pump_policy.hpp"
+#include "vacuum-module/errors.hpp"
+#include "vacuum-module/messages.hpp"
+#include "vacuum-module/tasks.hpp"
+#include "hal/message_queue.hpp"
+#include "messages.hpp"
+
+namespace pump_task {
+template <typename P>
+concept PumpControlPolicy = requires(P p) {
+    { p.sleep_ms(1) };
+};
+
+using PumpPolicy = pump_policy::PumpPolicy;
+using Message = messages::PumpMessage;
+using Error = errors::ErrorCode;
+
+template <template <class> class QueueImpl>
+requires MessageQueue<QueueImpl<Message>, Message>
+class PumpTask {
+  private:
+    using Queue = QueueImpl<Message>;
+    using Aggregator = typename tasks::Tasks<QueueImpl>::QueueAggregator;
+    using Queues = typename tasks::Tasks<QueueImpl>;
+
+  public:
+    explicit PumpTask(Queue& q, Aggregator* aggregator, PumpPolicy* policy)
+        : _message_queue(q),
+          _task_registry(aggregator) {}
+    PumpTask(const PumpTask& other) = delete;
+    auto operator=(const PumpTask& other) -> PumpTask& = delete;
+    PumpTask(PumpTask&& other) noexcept = delete;
+    auto operator=(PumpTask&& other) noexcept -> PumpTask& = delete;
+    ~PumpTask() = default;
+
+    auto provide_aggregator(Aggregator* aggregator) {
+        _task_registry = aggregator;
+    }
+
+    template <PumpControlPolicy Policy>
+    auto run_once(Policy& policy) -> void {
+        if (!_task_registry) {
+            return;
+        }
+
+        if (!_initialized) {
+            _message_queue.set_ready();
+            _initialized = true;
+        }
+
+        auto message = Message(std::monostate());
+        _message_queue.recv(&message);
+        auto visit_helper = [this, &policy](auto& message) -> void {
+            this->visit_message(message, policy);
+        };
+        std::visit(visit_helper, message);
+    }
+
+  private:
+    auto send_error_message(Error error) -> void {
+        if (_task_registry) {
+            auto msg = messages::ErrorMessage{.code = error};
+            static_cast<void>(
+                _task_registry->send_to_address(msg, Queues::HostCommsAddress));
+        }
+    }
+
+    auto send_ack_message(uint32_t response_id, Error error = Error::NO_ERROR)
+        -> void {
+        if (_task_registry) {
+            auto msg = messages::AcknowledgePrevious{
+                .responding_to_id = response_id, .with_error = error};
+            static_cast<void>(
+                _task_registry->send_to_address(msg, Queues::HostCommsAddress));
+        }
+    }
+
+    template <PumpControlPolicy Policy>
+    auto visit_message(const std::monostate& m, Policy& policy) -> void {
+        static_cast<void>(m);
+        static_cast<void>(policy);
+    }
+
+    template <PumpControlPolicy Policy>
+    auto visit_message(const messages::SetTargetRPMMessage& m, Policy& policy) -> void {
+        static_cast<void>(m);
+        static_cast<void>(policy);
+    }
+
+    Queue& _message_queue;
+    Aggregator* _task_registry;
+    bool _initialized{false};
+};
+
+}  // namespace pump_task

stm32-modules/include/vacuum-module/vacuum-module/tasks.hpp

@@ -19,10 +19,12 @@ struct Tasks {
     using UIQueue = QueueImpl<messages::UIMessage>;
     // Message queue for Pressure task
     using PressureQueue = QueueImpl<messages::PressureMessage>;
+    // Message queue for Pump task
+    using PumpQueue = QueueImpl<messages::PumpMessage>;
 
     // Central aggregator
     using QueueAggregator =
-        queue_aggregator::QueueAggregator<HostCommsQueue, SystemQueue, UIQueue, PressureQueue>;
+        queue_aggregator::QueueAggregator<HostCommsQueue, SystemQueue, UIQueue, PressureQueue, PumpQueue>;
 
     // Addresses
     static constexpr size_t HostCommsAddress =
@@ -33,6 +35,8 @@ struct Tasks {
         QueueAggregator::template get_queue_idx<UIQueue>();
     static constexpr size_t PressureAddress =
         QueueAggregator::template get_queue_idx<PressureQueue>();
+    static constexpr size_t PumpAddress =
+        QueueAggregator::template get_queue_idx<PumpQueue>();
 };
 
 };  // namespace tasks

stm32-modules/vacuum-module/firmware/CMakeLists.txt

@@ -13,10 +13,10 @@ set(COMMS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/host_comms_task")
 set(SYSTEM_DIR "${CMAKE_CURRENT_SOURCE_DIR}/system")
 set(UI_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ui")
 set(VENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vent")
-set(PUMP_DIR "${CMAKE_CURRENT_SOURCE_DIR}/pump")
 set(ATMOSPHERE_PS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/atmosphere-pressure-sensor")
 set(VACUUM_PS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vacuum-pressure-sensor")
 set(PRESSURE_CONTROL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/pressure_task")
+set(PUMP_CONTROL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/pump_task")
 
 # Add source files that should be checked by clang-tidy here
 set(${TARGET_MODULE_NAME}_FW_LINTABLE_SRCS
@@ -29,11 +29,12 @@ set(${TARGET_MODULE_NAME}_FW_LINTABLE_SRCS
     ${UI_DIR}/freertos_ui_task.cpp
     ${UI_DIR}/ui_policy.cpp
     ${VENT_DIR}/vent_policy.cpp
-    ${PUMP_DIR}/pump_policy.cpp
     ${ATMOSPHERE_PS_DIR}/atmosphere_pressure_sensor_policy.cpp
     ${VACUUM_PS_DIR}/vacuum_pressure_sensor_policy.cpp
     ${PRESSURE_CONTROL_DIR}/freertos_pressure_task.cpp
     ${PRESSURE_CONTROL_DIR}/pressure_policy.cpp
+    ${PUMP_CONTROL_DIR}/freertos_pump_task.cpp
+    ${PUMP_CONTROL_DIR}/pump_policy.cpp
     )
 
 # Add source files that should NOT be checked by clang-tidy here
@@ -50,7 +51,7 @@ set(${TARGET_MODULE_NAME}_FW_NONLINTABLE_SRCS
     ${COMMS_DIR}/usbd_desc.c
     ${COMMS_DIR}/usb_hardware.c
     ${VENT_DIR}/vent_hardware.c
-    ${PUMP_DIR}/pump_hardware.c
+    ${PUMP_CONTROL_DIR}/pump_hardware.c
     )
 
 add_executable(${TARGET_MODULE_NAME}

stm32-modules/vacuum-module/firmware/main.cpp

@@ -23,6 +23,8 @@ using EntryPointUI = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
                                         i2c::hardware::I2C *)>;
 using EntryPointPressure = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
                                         i2c::hardware::I2C *)>;
+using EntryPointPump = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
+                                        i2c::hardware::I2C *)>;
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto ui_task_entry = EntryPointUI(ui_control_task::run);
@@ -32,6 +34,8 @@ static auto host_comms_entry = EntryPoint(host_comms_control_task::run);
 static auto system_task_entry = EntryPoint(system_control_task::run);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto pressure_task_entry = EntryPointPressure(pressure_control_task::run);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static auto pump_task_entry = EntryPointPump(pump_control_task::run);
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto host_comms_task =
@@ -49,6 +53,10 @@ static auto system_task =
 static auto pressure_task =
     ot_utils::freertos_task::FreeRTOSTask<tasks::PRESSURE_STACK_SIZE, EntryPointPressure>(
         pressure_task_entry);
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static auto pump_task =
+    ot_utils::freertos_task::FreeRTOSTask<tasks::PUMP_STACK_SIZE, EntryPointPump>(
+        pump_task_entry);
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto aggregator = tasks::FirmwareTasks::QueueAggregator();
@@ -74,6 +82,7 @@ auto main() -> int {
     host_comms_task.start(tasks::COMMS_TASK_PRIORITY, "Comms", &aggregator);
     ui_task.start(tasks::UI_TASK_PRIORITY, "UI", &aggregator, &i2c2_comms);
     pressure_task.start(tasks::PRESSURE_TASK_PRIORITY, "Pressure", &aggregator, &i2c2_comms);
+    pump_task.start(tasks::PUMP_TASK_PRIORITY, "Pump", &aggregator, &i2c2_comms);
 
     vTaskStartScheduler();
     return 0;