rename ControlTask -> PressureTask

Author: vegano1

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

@@ -21,6 +21,6 @@ constexpr uint8_t SYSTEM_TASK_PRIORITY = 1;
 constexpr size_t UI_STACK_SIZE = 256;
 constexpr uint8_t UI_TASK_PRIORITY = 1;
 
-constexpr size_t CONTROL_STACK_SIZE = 256;
-constexpr uint8_t CONTROL_TASK_PRIORITY = 1;
+constexpr size_t PRESSURE_STACK_SIZE = 256;
+constexpr uint8_t PRESSURE_TASK_PRIORITY = 1;
 }  // namespace tasks

stm32-modules/include/vacuum-module/firmware/control_policy.hpp renamed to stm32-modules/include/vacuum-module/firmware/pressure_policy.hpp

@@ -5,12 +5,12 @@
 #include "i2c_comms.hpp"
 #include "systemwide.h"
 
-namespace control_policy {
+namespace pressure_policy {
 using namespace i2c::hardware;
 
-class ControlPolicy {
+class PressurePolicy {
   public:
-    ControlPolicy(I2C *i2c) : i2c_comms{i2c} {}
+    PressurePolicy(I2C *i2c) : i2c_comms{i2c} {}
 
     template <size_t Len>
     auto i2c_write(uint8_t device_address, uint8_t register_address,
@@ -24,4 +24,4 @@ class ControlPolicy {
   private:
     I2C *i2c_comms;
 };
-}  // namespace control_policy
+}  // namespace pressure_policy

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

@@ -122,6 +122,6 @@ using SystemMessage =
 
 using UIMessage = ::std::variant<std::monostate, SetStatusBarStateMessage>;
 
-using ControlMessage = ::std::variant<std::monostate>;
+using PressureMessage = ::std::variant<std::monostate>;
 
 };  // namespace messages

stm32-modules/include/vacuum-module/vacuum-module/control_task.hpp renamed to stm32-modules/include/vacuum-module/vacuum-module/pressure_task.hpp

@@ -5,40 +5,40 @@
 #include "core/ack_cache.hpp"
 #include "core/queue_aggregator.hpp"
 #include "core/version.hpp"
-#include "firmware/control_policy.hpp"
+#include "firmware/pressure_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 control_task {
+namespace pressure_task {
 template <typename P>
 concept PressureControlPolicy = requires(P p) {
     { p.sleep_ms(1) };
 };
 
-using ControlPolicy = control_policy::ControlPolicy;
-using Message = messages::ControlMessage;
+using PressurePolicy = pressure_policy::PressurePolicy;
+using Message = messages::PressureMessage;
 using Error = errors::ErrorCode;
 
 template <template <class> class QueueImpl>
 requires MessageQueue<QueueImpl<Message>, Message>
-class ControlTask {
+class PressureTask {
   private:
     using Queue = QueueImpl<Message>;
     using Aggregator = typename tasks::Tasks<QueueImpl>::QueueAggregator;
     using Queues = typename tasks::Tasks<QueueImpl>;
 
   public:
-    explicit ControlTask(Queue& q, Aggregator* aggregator, ControlPolicy* policy)
+    explicit PressureTask(Queue& q, Aggregator* aggregator, PressurePolicy* policy)
         : _message_queue(q),
           _task_registry(aggregator) {}
-    ControlTask(const ControlTask& other) = delete;
-    auto operator=(const ControlTask& other) -> ControlTask& = delete;
-    ControlTask(ControlTask&& other) noexcept = delete;
-    auto operator=(ControlTask&& other) noexcept -> ControlTask& = delete;
-    ~ControlTask() = default;
+    PressureTask(const PressureTask& other) = delete;
+    auto operator=(const PressureTask& other) -> PressureTask& = delete;
+    PressureTask(PressureTask&& other) noexcept = delete;
+    auto operator=(PressureTask&& other) noexcept -> PressureTask& = delete;
+    ~PressureTask() = default;
 
     auto provide_aggregator(Aggregator* aggregator) {
         _task_registry = aggregator;
@@ -93,4 +93,4 @@ class ControlTask {
     bool _initialized{false};
 };
 
-}  // namespace control_task
+}  // namespace pressure_task

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

@@ -17,12 +17,12 @@ struct Tasks {
     using SystemQueue = QueueImpl<messages::SystemMessage>;
     // Message queue for UI task
     using UIQueue = QueueImpl<messages::UIMessage>;
-    // Message queue for Control task
-    using ControlQueue = QueueImpl<messages::ControlMessage>;
+    // Message queue for Pressure task
+    using PressureQueue = QueueImpl<messages::PressureMessage>;
 
     // Central aggregator
     using QueueAggregator =
-        queue_aggregator::QueueAggregator<HostCommsQueue, SystemQueue, UIQueue, ControlQueue>;
+        queue_aggregator::QueueAggregator<HostCommsQueue, SystemQueue, UIQueue, PressureQueue>;
 
     // Addresses
     static constexpr size_t HostCommsAddress =
@@ -31,8 +31,8 @@ struct Tasks {
         QueueAggregator::template get_queue_idx<SystemQueue>();
     static constexpr size_t UIAddress =
         QueueAggregator::template get_queue_idx<UIQueue>();
-    static constexpr size_t ControlAddress =
-        QueueAggregator::template get_queue_idx<ControlQueue>();
+    static constexpr size_t PressureAddress =
+        QueueAggregator::template get_queue_idx<PressureQueue>();
 };
 
 };  // namespace tasks

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

@@ -16,6 +16,7 @@ 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")
 
 # Add source files that should be checked by clang-tidy here
 set(${TARGET_MODULE_NAME}_FW_LINTABLE_SRCS
@@ -31,8 +32,8 @@ set(${TARGET_MODULE_NAME}_FW_LINTABLE_SRCS
     ${PUMP_DIR}/pump_policy.cpp
     ${ATMOSPHERE_PS_DIR}/atmosphere_pressure_sensor_policy.cpp
     ${VACUUM_PS_DIR}/vacuum_pressure_sensor_policy.cpp
-    ${CONTROL_DIR}/freertos_control_task.cpp
-    ${CONTROL_DIR}/control_policy.cpp
+    ${PRESSURE_CONTROL_DIR}/freertos_pressure_task.cpp
+    ${PRESSURE_CONTROL_DIR}/pressure_policy.cpp
     )
 
 # Add source files that should NOT be checked by clang-tidy here

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

@@ -21,7 +21,7 @@
 using EntryPoint = std::function<void(tasks::FirmwareTasks::QueueAggregator *)>;
 using EntryPointUI = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
                                         i2c::hardware::I2C *)>;
-using EntryPointControl = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
+using EntryPointPressure = std::function<void(tasks::FirmwareTasks::QueueAggregator *,
                                         i2c::hardware::I2C *)>;
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -31,7 +31,7 @@ static auto host_comms_entry = EntryPoint(host_comms_control_task::run);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto system_task_entry = EntryPoint(system_control_task::run);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static auto control_task_entry = EntryPointControl(pressure_control_task::run);
+static auto pressure_task_entry = EntryPointPressure(pressure_control_task::run);
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static auto host_comms_task =
@@ -46,9 +46,9 @@ static auto system_task =
     ot_utils::freertos_task::FreeRTOSTask<tasks::SYSTEM_STACK_SIZE, EntryPoint>(
         system_task_entry);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static auto control_task =
-    ot_utils::freertos_task::FreeRTOSTask<tasks::CONTROL_STACK_SIZE, EntryPointControl>(
-        control_task_entry);
+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 aggregator = tasks::FirmwareTasks::QueueAggregator();
@@ -73,7 +73,7 @@ auto main() -> int {
     system_task.start(tasks::SYSTEM_TASK_PRIORITY, "System", &aggregator);
     host_comms_task.start(tasks::COMMS_TASK_PRIORITY, "Comms", &aggregator);
     ui_task.start(tasks::UI_TASK_PRIORITY, "UI", &aggregator, &i2c2_comms);
-    control_task.start(tasks::CONTROL_TASK_PRIORITY, "Control", &aggregator, &i2c2_comms);
+    pressure_task.start(tasks::PRESSURE_TASK_PRIORITY, "Pressure", &aggregator, &i2c2_comms);
 
     vTaskStartScheduler();
     return 0;

stm32-modules/vacuum-module/firmware/control_task/freertos_control_task.cpp renamed to stm32-modules/vacuum-module/firmware/pressure_task/freertos_pressure_task.cpp

@@ -4,24 +4,24 @@
 #include "firmware/firmware_tasks.hpp"
 #include "firmware/freertos_tasks.hpp"
 #include "firmware/i2c_comms.hpp"
-#include "firmware/control_policy.hpp"
-#include "vacuum-module/control_task.hpp"
+#include "firmware/pressure_policy.hpp"
+#include "vacuum-module/pressure_task.hpp"
 #include "task.h"
 
 namespace pressure_control_task {
-using namespace control_policy;
+using namespace pressure_policy;
 
 enum class Notifications : uint8_t {
     INCOMING_MESSAGE = 1,
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static tasks::FirmwareTasks::ControlQueue
+static tasks::FirmwareTasks::PressureQueue
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    _queue(static_cast<uint8_t>(Notifications::INCOMING_MESSAGE), "Control Queue");
+    _queue(static_cast<uint8_t>(Notifications::INCOMING_MESSAGE), "Pressure Queue");
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static auto _top_task = control_task::ControlTask(_queue, nullptr, nullptr);
+static auto _top_task = pressure_task::PressureTask(_queue, nullptr, nullptr);
 
 auto run(tasks::FirmwareTasks::QueueAggregator* aggregator,
          i2c::hardware::I2C* i2c1_comms) -> void {
@@ -30,7 +30,7 @@ auto run(tasks::FirmwareTasks::QueueAggregator* aggregator,
     aggregator->register_queue(_queue);
     _top_task.provide_aggregator(aggregator);
 
-    auto policy = ControlPolicy(i2c1_comms);
+    auto policy = PressurePolicy(i2c1_comms);
     while (true) {
         _top_task.run_once(policy);
     }

stm32-modules/vacuum-module/firmware/control_task/control_policy.cpp renamed to stm32-modules/vacuum-module/firmware/pressure_task/pressure_policy.cpp

@@ -1,15 +1,15 @@
-#include "firmware/control_policy.hpp"
+#include "firmware/pressure_policy.hpp"
 
 #include <cstdint>
 
 #include "FreeRTOS.h"
 #include "projdefs.h"
 #include "task.h"
 
-using namespace control_policy;
+using namespace pressure_policy;
 
 
 // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-auto ControlPolicy::sleep_ms(uint32_t ms) -> void {
+auto PressurePolicy::sleep_ms(uint32_t ms) -> void {
     vTaskDelay(pdMS_TO_TICKS(ms));
 }