From 7ff6133f10383721f45b803ee96df85311f8047c Mon Sep 17 00:00:00 2001
From: caila-marashaj <caila.marashaj@opentrons.com>
Date: Mon, 29 Jan 2024 15:32:52 -0500
Subject: [PATCH] format

---
 .../can/core/message_handlers/move_group.hpp  |  9 +--
 include/can/core/messages.hpp                 | 17 +++--
 include/motor-control/core/motor_messages.hpp | 20 +++---
 .../core/stepper_motor/motion_controller.hpp  | 24 +++----
 .../stepper_motor/motor_interrupt_handler.hpp | 42 ++++++-------
 include/motor-control/core/tasks/messages.hpp | 32 +++++-----
 .../core/tasks/motion_controller_task.hpp     |  1 -
 .../core/tasks/move_group_task.hpp            | 12 ++--
 include/pipettes/core/dispatch_builder.hpp    |  7 ++-
 .../pipettes/core/motor_interrupt_handler.hpp | 63 +++++++++----------
 include/pipettes/firmware/interfaces_g4.hpp   |  6 +-
 pipettes/firmware/main.cpp                    |  3 +-
 12 files changed, 116 insertions(+), 120 deletions(-)

diff --git a/include/can/core/message_handlers/move_group.hpp b/include/can/core/message_handlers/move_group.hpp
index 9cd589ad6..a0f7e79fe 100644
--- a/include/can/core/message_handlers/move_group.hpp
+++ b/include/can/core/message_handlers/move_group.hpp
@@ -15,12 +15,13 @@ class MoveGroupHandler {
     using MessageType =
         std::variant<std::monostate, AddLinearMoveRequest,
                      ClearAllMoveGroupsRequest, ExecuteMoveGroupRequest,
-                     GetMoveGroupRequest, HomeRequest, StopRequest, AddSensorMoveRequest>;
+                     GetMoveGroupRequest, HomeRequest, StopRequest,
+                     AddSensorMoveRequest>;
 #else
     using MessageType =
-            std::variant<std::monostate, AddLinearMoveRequest,
-                    ClearAllMoveGroupsRequest, ExecuteMoveGroupRequest,
-                    GetMoveGroupRequest, HomeRequest, StopRequest>;
+        std::variant<std::monostate, AddLinearMoveRequest,
+                     ClearAllMoveGroupsRequest, ExecuteMoveGroupRequest,
+                     GetMoveGroupRequest, HomeRequest, StopRequest>;
 #endif
 
     MoveGroupHandler(Client &task_client) : task_client{task_client} {}
diff --git a/include/can/core/messages.hpp b/include/can/core/messages.hpp
index ba3484499..dbdfcc7a5 100644
--- a/include/can/core/messages.hpp
+++ b/include/can/core/messages.hpp
@@ -1591,21 +1591,20 @@ struct AddSensorMoveRequest : BaseMessage<MessageId::add_sensor_move_request> {
         body = bit_utils::bytes_to_int(body, limit, request_stop_condition);
         body = bit_utils::bytes_to_int(body, limit, sensor_id);
         return AddSensorMoveRequest{
-                .message_index = msg_ind,
-                .group_id = group_id,
-                .seq_id = seq_id,
-                .duration = duration,
-                .acceleration = acceleration,
-                .velocity = velocity,
-                .request_stop_condition = request_stop_condition,
-                .sensor_id = static_cast<can::ids::SensorId>(sensor_id),
+            .message_index = msg_ind,
+            .group_id = group_id,
+            .seq_id = seq_id,
+            .duration = duration,
+            .acceleration = acceleration,
+            .velocity = velocity,
+            .request_stop_condition = request_stop_condition,
+            .sensor_id = static_cast<can::ids::SensorId>(sensor_id),
         };
     }
 
     auto operator==(const AddSensorMoveRequest& other) const -> bool = default;
 };
 
-
 /**
  * A variant of all message types we might send..
  */
diff --git a/include/motor-control/core/motor_messages.hpp b/include/motor-control/core/motor_messages.hpp
index 27c47da2d..724790659 100644
--- a/include/motor-control/core/motor_messages.hpp
+++ b/include/motor-control/core/motor_messages.hpp
@@ -80,20 +80,20 @@ struct Move {  // NOLINT(cppcoreguidelines-pro-type-member-init)
 };
 
 struct SensorSyncMove  // NOLINT(cppcoreguidelines-pro-type-member-init)
-        : public Move {
+    : public Move {
     can::ids::SensorId sensor_id;
 
     auto build_ack(int32_t pulses, uint8_t flags, AckMessageId _id) -> Ack {
         return Ack{
-                .message_index = message_index,
-                .group_id = group_id,
-                .seq_id = seq_id,
-                .current_position_steps = 0,
-                .encoder_position = pulses,
-                .position_flags = flags,
-                .ack_id = _id,
-                .start_encoder_position = start_encoder_position,
-                .usage_key = usage_key,
+            .message_index = message_index,
+            .group_id = group_id,
+            .seq_id = seq_id,
+            .current_position_steps = 0,
+            .encoder_position = pulses,
+            .position_flags = flags,
+            .ack_id = _id,
+            .start_encoder_position = start_encoder_position,
+            .usage_key = usage_key,
         };
     }
 };
diff --git a/include/motor-control/core/stepper_motor/motion_controller.hpp b/include/motor-control/core/stepper_motor/motion_controller.hpp
index dede8841b..6ee1f379d 100644
--- a/include/motor-control/core/stepper_motor/motion_controller.hpp
+++ b/include/motor-control/core/stepper_motor/motion_controller.hpp
@@ -61,20 +61,20 @@ class MotionController {
 
     void move(const can::messages::AddSensorMoveRequest& can_msg) {
         steps_per_tick velocity_steps =
-                fixed_point_multiply(steps_per_mm, can_msg.velocity);
+            fixed_point_multiply(steps_per_mm, can_msg.velocity);
         steps_per_tick_sq acceleration_steps =
-                fixed_point_multiply(steps_per_um, can_msg.acceleration);
+            fixed_point_multiply(steps_per_um, can_msg.acceleration);
         SensorSyncMove msg{
-                can_msg.message_index,
-                can_msg.duration,
-                velocity_steps,
-                acceleration_steps,
-                can_msg.group_id,
-                can_msg.seq_id,
-                can_msg.request_stop_condition,
-                0,
-                hardware.get_usage_eeprom_config().get_distance_key(),
-                can_msg.sensor_id};
+            can_msg.message_index,
+            can_msg.duration,
+            velocity_steps,
+            acceleration_steps,
+            can_msg.group_id,
+            can_msg.seq_id,
+            can_msg.request_stop_condition,
+            0,
+            hardware.get_usage_eeprom_config().get_distance_key(),
+            can_msg.sensor_id};
         if (!enabled) {
             enable_motor();
         }
diff --git a/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp b/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
index 4dc7763b9..c70c369e9 100644
--- a/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
+++ b/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
@@ -594,26 +594,26 @@ class MotorInterruptHandler {
         return has_active_move() && buffered_move.velocity != 0;
     }
 
-protected:
-void update_hardware_step_tracker() {
-    hardware.set_step_tracker(
-        static_cast<uint32_t>(position_tracker >> 31));
-}
-
-uint64_t tick_count = 0x0;
-static constexpr const q31_31 tick_flag = 0x80000000;
-static constexpr const uint64_t overflow_flag = 0x8000000000000000;
-// Tracks position with sub-microstep accuracy
-q31_31 position_tracker{0};
-MoveQueue& move_queue;
-StatusClient& status_queue_client;
-MotorHardware& hardware;
-stall_check::StallCheck& stall_checker;
-UpdatePositionQueue& update_position_queue;
-MotorMoveMessage buffered_move = MotorMoveMessage{};
-bool clear_queue_until_empty = false;
-bool stall_handled = false;
-bool in_estop = false;
-std::atomic_bool _has_active_move = false;
+  protected:
+    void update_hardware_step_tracker() {
+        hardware.set_step_tracker(
+            static_cast<uint32_t>(position_tracker >> 31));
+    }
+
+    uint64_t tick_count = 0x0;
+    static constexpr const q31_31 tick_flag = 0x80000000;
+    static constexpr const uint64_t overflow_flag = 0x8000000000000000;
+    // Tracks position with sub-microstep accuracy
+    q31_31 position_tracker{0};
+    MoveQueue& move_queue;
+    StatusClient& status_queue_client;
+    MotorHardware& hardware;
+    stall_check::StallCheck& stall_checker;
+    UpdatePositionQueue& update_position_queue;
+    MotorMoveMessage buffered_move = MotorMoveMessage{};
+    bool clear_queue_until_empty = false;
+    bool stall_handled = false;
+    bool in_estop = false;
+    std::atomic_bool _has_active_move = false;
 };
 }  // namespace motor_handler
diff --git a/include/motor-control/core/tasks/messages.hpp b/include/motor-control/core/tasks/messages.hpp
index 1e27fb529..c49ac5563 100644
--- a/include/motor-control/core/tasks/messages.hpp
+++ b/include/motor-control/core/tasks/messages.hpp
@@ -22,27 +22,27 @@ using MoveGroupTaskMessage =
                  can::messages::ClearAllMoveGroupsRequest,
                  can::messages::ExecuteMoveGroupRequest,
                  can::messages::GetMoveGroupRequest, can::messages::HomeRequest,
-                 can::messages::StopRequest, can::messages::AddSensorMoveRequest>;
+                 can::messages::StopRequest,
+                 can::messages::AddSensorMoveRequest>;
 #else
 using MotionControlTaskMessage = std::variant<
-        std::monostate, can::messages::AddLinearMoveRequest,
-        can::messages::DisableMotorRequest, can::messages::EnableMotorRequest,
-        can::messages::GetMotionConstraintsRequest,
-        can::messages::SetMotionConstraints, can::messages::StopRequest,
-        can::messages::MotorPositionRequest, can::messages::ReadLimitSwitchRequest,
-        can::messages::HomeRequest,
-        can::messages::UpdateMotorPositionEstimationRequest,
-        can::messages::GetMotorUsageRequest>;
+    std::monostate, can::messages::AddLinearMoveRequest,
+    can::messages::DisableMotorRequest, can::messages::EnableMotorRequest,
+    can::messages::GetMotionConstraintsRequest,
+    can::messages::SetMotionConstraints, can::messages::StopRequest,
+    can::messages::MotorPositionRequest, can::messages::ReadLimitSwitchRequest,
+    can::messages::HomeRequest,
+    can::messages::UpdateMotorPositionEstimationRequest,
+    can::messages::GetMotorUsageRequest>;
 
-    using MoveGroupTaskMessage =
-            std::variant<std::monostate, can::messages::AddLinearMoveRequest,
-                    can::messages::ClearAllMoveGroupsRequest,
-                    can::messages::ExecuteMoveGroupRequest,
-                    can::messages::GetMoveGroupRequest, can::messages::HomeRequest,
-                    can::messages::StopRequest>;
+using MoveGroupTaskMessage =
+    std::variant<std::monostate, can::messages::AddLinearMoveRequest,
+                 can::messages::ClearAllMoveGroupsRequest,
+                 can::messages::ExecuteMoveGroupRequest,
+                 can::messages::GetMoveGroupRequest, can::messages::HomeRequest,
+                 can::messages::StopRequest>;
 #endif
 
-
 using MotorDriverTaskMessage =
     std::variant<std::monostate, can::messages::ReadMotorDriverRegister,
                  can::messages::WriteMotorDriverRegister,
diff --git a/include/motor-control/core/tasks/motion_controller_task.hpp b/include/motor-control/core/tasks/motion_controller_task.hpp
index 6a0e3025d..dfb833424 100644
--- a/include/motor-control/core/tasks/motion_controller_task.hpp
+++ b/include/motor-control/core/tasks/motion_controller_task.hpp
@@ -150,7 +150,6 @@ class MotionControllerMessageHandler {
         controller.send_usage_data(m.message_index, usage_client);
     }
 
-
     MotorControllerType& controller;
     CanClient& can_client;
     UsageClient& usage_client;
diff --git a/include/motor-control/core/tasks/move_group_task.hpp b/include/motor-control/core/tasks/move_group_task.hpp
index 041fbe3d5..789cbd808 100644
--- a/include/motor-control/core/tasks/move_group_task.hpp
+++ b/include/motor-control/core/tasks/move_group_task.hpp
@@ -15,16 +15,14 @@ namespace move_group_task {
 constexpr std::size_t max_groups = 3;
 constexpr std::size_t max_moves_per_group = 12;
 #ifdef PIPETTE_TYPE_DEFINE
+using MoveGroupType = move_group::MoveGroupManager<
+    max_groups, max_moves_per_group, can::messages::AddLinearMoveRequest,
+    can::messages::HomeRequest, can::messages::AddSensorMoveRequest>;
+#else
 using MoveGroupType =
     move_group::MoveGroupManager<max_groups, max_moves_per_group,
                                  can::messages::AddLinearMoveRequest,
-                                 can::messages::HomeRequest,
-                                 can::messages::AddSensorMoveRequest>;
-#else
-using MoveGroupType =
-        move_group::MoveGroupManager<max_groups, max_moves_per_group,
-                can::messages::AddLinearMoveRequest,
-                can::messages::HomeRequest>;
+                                 can::messages::HomeRequest>;
 #endif
 
 using TaskMessage = motor_control_task_messages::MoveGroupTaskMessage;
diff --git a/include/pipettes/core/dispatch_builder.hpp b/include/pipettes/core/dispatch_builder.hpp
index 00e60e019..88d98b4bf 100644
--- a/include/pipettes/core/dispatch_builder.hpp
+++ b/include/pipettes/core/dispatch_builder.hpp
@@ -46,11 +46,12 @@ using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
     can::messages::AddLinearMoveRequest,
     can::messages::ClearAllMoveGroupsRequest,
     can::messages::ExecuteMoveGroupRequest, can::messages::GetMoveGroupRequest,
-    can::messages::HomeRequest, can::messages::StopRequest, can::messages::AddSensorMoveRequest>;
+    can::messages::HomeRequest, can::messages::StopRequest,
+    can::messages::AddSensorMoveRequest>;
 #else
-    using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
+using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
     can::message_handlers::move_group::MoveGroupHandler<
-            linear_motor_tasks::QueueClient>,
+        linear_motor_tasks::QueueClient>,
     can::messages::AddLinearMoveRequest,
     can::messages::ClearAllMoveGroupsRequest,
     can::messages::ExecuteMoveGroupRequest, can::messages::GetMoveGroupRequest,
diff --git a/include/pipettes/core/motor_interrupt_handler.hpp b/include/pipettes/core/motor_interrupt_handler.hpp
index 74597b759..5f47f02ac 100644
--- a/include/pipettes/core/motor_interrupt_handler.hpp
+++ b/include/pipettes/core/motor_interrupt_handler.hpp
@@ -10,9 +10,9 @@ template <template <class> class QueueImpl, class StatusClient,
 requires MessageQueue<QueueImpl<MotorMoveMessage>, MotorMoveMessage> &&
     std::is_base_of_v<motor_hardware::MotorHardwareIface, MotorHardware>
 class PipetteMotorInterruptHandler
-: public motor_handler::MotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, StatusClient,
-    MotorMoveMessage, MotorHardware> {
+    : public motor_handler::MotorInterruptHandler<
+          freertos_message_queue::FreeRTOSMessageQueue, StatusClient,
+          MotorMoveMessage, MotorHardware> {
   public:
     using MoveQueue = QueueImpl<MotorMoveMessage>;
     using UpdatePositionQueue =
@@ -22,13 +22,13 @@ class PipetteMotorInterruptHandler
         MoveQueue& incoming_move_queue, StatusClient& outgoing_queue,
         MotorHardware& hardware_iface, stall_check::StallCheck& stall,
         UpdatePositionQueue& incoming_update_position_queue,
-        SensorClient& sensor_queue_client) :
-            motor_handler::MotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, StatusClient,
-    MotorMoveMessage, MotorHardware>(incoming_move_queue, outgoing_queue, hardware_iface,
-                           stall, incoming_update_position_queue),
-          sensor_client(sensor_queue_client) {
-        }
+        SensorClient& sensor_queue_client)
+        : motor_handler::MotorInterruptHandler<
+              freertos_message_queue::FreeRTOSMessageQueue, StatusClient,
+              MotorMoveMessage, MotorHardware>(
+              incoming_move_queue, outgoing_queue, hardware_iface, stall,
+              incoming_update_position_queue),
+          sensor_client(sensor_queue_client) {}
 
     ~PipetteMotorInterruptHandler() = default;
 
@@ -64,33 +64,32 @@ class PipetteMotorInterruptHandler
             this->in_estop = true;
         } else if (this->hardware.has_cancel_request()) {
             this->cancel_and_clear_moves(can::ids::ErrorCode::stop_requested,
-                                   can::ids::ErrorSeverity::warning);
+                                         can::ids::ErrorSeverity::warning);
         } else {
             // Normal Move logic
             this->run_normal_interrupt();
         }
     }
 
-    void handle_move_type(motor_messages::Move m) {
-    }
+    void handle_move_type(motor_messages::Move m) {}
 
     void handle_move_type(motor_messages::SensorSyncMove m) {
         auto msg = can::messages::BindSensorOutputRequest{
             .message_index = m.message_index,
             .sensor = can::ids::SensorType::pressure,
             .sensor_id = m.sensor_id,
-            .binding = can::ids::SensorOutputBinding::report
-        };
+            .binding = can::ids::SensorOutputBinding::report};
         send_to_pressure_sensor_queue(&msg);
     }
 
     void update_move() {
-        this->_has_active_move = this->move_queue.try_read_isr(&this->buffered_move);
+        this->_has_active_move =
+            this->move_queue.try_read_isr(&this->buffered_move);
         if (this->_has_active_move) {
             handle_move_type(this->buffered_move);
             this->hardware.enable_encoder();
             this->buffered_move.start_encoder_position =
-                    this->hardware.get_encoder_pulses();
+                this->hardware.get_encoder_pulses();
         }
         if (this->set_direction_pin()) {
             this->hardware.positive_direction();
@@ -98,49 +97,47 @@ class PipetteMotorInterruptHandler
             this->hardware.negative_direction();
         }
         if (this->_has_active_move && this->buffered_move.check_stop_condition(
-                MoveStopCondition::limit_switch)) {
+                                          MoveStopCondition::limit_switch)) {
             this->position_tracker = 0x7FFFFFFFFFFFFFFF;
             this->update_hardware_step_tracker();
             this->hardware.position_flags.clear_flag(
-                    can::ids::MotorPositionFlags::stepper_position_ok);
+                can::ids::MotorPositionFlags::stepper_position_ok);
             this->hardware.position_flags.clear_flag(
-                    can::ids::MotorPositionFlags::encoder_position_ok);
+                can::ids::MotorPositionFlags::encoder_position_ok);
         }
     }
 
     void finish_current_move(
-            AckMessageId ack_msg_id = AckMessageId::complete_without_condition) {
+        AckMessageId ack_msg_id = AckMessageId::complete_without_condition) {
         this->_has_active_move = false;
         this->tick_count = 0x0;
         this->stall_handled = false;
-        this->build_and_send_ack(ack_msg_id);  // might want to overwrite this func
+        this->build_and_send_ack(
+            ack_msg_id);  // might want to overwrite this func
         (MotorMoveMessage{});
         // update the stall check ideal encoder counts based on
         // last known location
 
         if (!this->has_move_messages()) {
-            this->stall_checker.reset_itr_counts(this->hardware.get_step_tracker());
+            this->stall_checker.reset_itr_counts(
+                this->hardware.get_step_tracker());
             auto& stop_msg = can::messages::BindSensorOutputRequest{
-                    .message_index = this->buffered_move.message_index,
-                    .sensor = can::ids::SensorType::pressure,
-                    .sensor_id = this->buffered_move.sensor_id,
-                    .binding = can::ids::SensorOutputBinding::none
-            };
+                .message_index = this->buffered_move.message_index,
+                .sensor = can::ids::SensorType::pressure,
+                .sensor_id = this->buffered_move.sensor_id,
+                .binding = can::ids::SensorOutputBinding::none};
             send_to_pressure_sensor_queue(&stop_msg);
         }
     }
 
     void send_to_pressure_sensor_queue(can::messages::SensorOutputBinding& m) {
-        if(this->buffered_move.sensor_id == can::ids::SensorId::S1) {
+        if (this->buffered_move.sensor_id == can::ids::SensorId::S1) {
             sensor_client.send_pressure_sensor_queue_front(m);
-        }
-        else {
+        } else {
             sensor_client.send_pressure_sensor_queue_rear(m);
         }
     }
 
-
-
   private:
     SensorClient& sensor_client;
 };
diff --git a/include/pipettes/firmware/interfaces_g4.hpp b/include/pipettes/firmware/interfaces_g4.hpp
index c417f5f96..21ede9d80 100644
--- a/include/pipettes/firmware/interfaces_g4.hpp
+++ b/include/pipettes/firmware/interfaces_g4.hpp
@@ -3,12 +3,12 @@
 #include "motor-control/core/motor_messages.hpp"
 #include "motor-control/core/stall_check.hpp"
 #include "motor-control/core/stepper_motor/motor_interrupt_handler.hpp"
-#include "pipettes/core/motor_interrupt_handler.hpp"
 #include "motor-control/firmware/stepper_motor/motor_hardware.hpp"
 #include "pipettes/core/gear_motor_tasks.hpp"
 #include "pipettes/core/interfaces.hpp"
 #include "pipettes/core/linear_motor_tasks.hpp"
 #include "pipettes/core/motor_configurations.hpp"
+#include "pipettes/core/motor_interrupt_handler.hpp"
 #include "pipettes/core/pipette_type.h"
 
 #pragma GCC diagnostic push
@@ -38,8 +38,8 @@ using GearMotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     motor_messages::GearMotorMove, motor_hardware::MotorHardware>;
 template <typename Client>
 using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
-        freertos_message_queue::FreeRTOSMessageQueue, Client, motor_messages::Move,
-        motor_hardware::MotorHardware, sensor_tasks::QueueClient>;
+    freertos_message_queue::FreeRTOSMessageQueue, Client, motor_messages::Move,
+    motor_hardware::MotorHardware, sensor_tasks::QueueClient>;
 
 template <PipetteType P>
 auto get_interrupt_queues()
diff --git a/pipettes/firmware/main.cpp b/pipettes/firmware/main.cpp
index c9b660e55..d5104c81e 100644
--- a/pipettes/firmware/main.cpp
+++ b/pipettes/firmware/main.cpp
@@ -101,7 +101,8 @@ static auto linear_motor_hardware =
     interfaces::linear_motor::get_motor_hardware(
         motor_config.hardware_pins.linear_motor);
 static auto plunger_interrupt = interfaces::linear_motor::get_interrupt(
-    linear_motor_hardware, interrupt_queues, linear_stall_check, sensor_queue_client);
+    linear_motor_hardware, interrupt_queues, linear_stall_check,
+    sensor_queue_client);
 static auto linear_motion_control =
     interfaces::linear_motor::get_motion_control(linear_motor_hardware,
                                                  interrupt_queues);