diff --git a/.github/workflows/cross-compile-special-sensors.yaml b/.github/workflows/cross-compile-special-sensors.yaml
index 152de1eb1..bc6798960 100644
--- a/.github/workflows/cross-compile-special-sensors.yaml
+++ b/.github/workflows/cross-compile-special-sensors.yaml
@@ -24,6 +24,7 @@ jobs:
           pipettes-single,
           pipettes-multi,
           pipettes-96,
+          gripper,
         ]
       fail-fast: false
     name: Build ${{ matrix.target }}
@@ -89,6 +90,7 @@ jobs:
       matrix:
         target: [
           pipettes,
+          gripper,
         ]
     steps:
       - name: Checkout ot3-firmware repo
diff --git a/gripper/firmware/interfaces_z_motor.cpp b/gripper/firmware/interfaces_z_motor.cpp
index cb6d1c3c0..b272faa79 100644
--- a/gripper/firmware/interfaces_z_motor.cpp
+++ b/gripper/firmware/interfaces_z_motor.cpp
@@ -199,7 +199,7 @@ static motor_class::Motor z_motor{
 static motor_handler::MotorInterruptHandler motor_interrupt(
     motor_queue, gripper_tasks::z_tasks::get_queues(),
     gripper_tasks::z_tasks::get_queues(), motor_hardware_iface, stallcheck,
-    update_position_queue);
+    update_position_queue, gripper_tasks::get_main_queues()); // use USE_SENSOR_MOVE
 
 static auto encoder_background_timer =
     motor_encoder::BackgroundTimer(motor_interrupt, motor_hardware_iface);
diff --git a/include/bootloader/core/ids.h b/include/bootloader/core/ids.h
index e51d6cbb6..bbd118211 100644
--- a/include/bootloader/core/ids.h
+++ b/include/bootloader/core/ids.h
@@ -114,7 +114,7 @@ typedef enum {
     can_messageid_peripheral_status_request = 0x8c,
     can_messageid_peripheral_status_response = 0x8d,
     can_messageid_baseline_sensor_response = 0x8e,
-    can_messageid_send_accumulated_pressure_data = 0x8f,
+    can_messageid_send_accumulated_sensor_data = 0x8f,
     can_messageid_set_hepa_fan_state_request = 0x90,
     can_messageid_get_hepa_fan_state_request = 0x91,
     can_messageid_get_hepa_fan_state_response = 0x92,
diff --git a/include/can/core/ids.hpp b/include/can/core/ids.hpp
index 2c5dd4169..2ffd1c398 100644
--- a/include/can/core/ids.hpp
+++ b/include/can/core/ids.hpp
@@ -118,7 +118,7 @@ enum class MessageId {
     peripheral_status_request = 0x8c,
     peripheral_status_response = 0x8d,
     baseline_sensor_response = 0x8e,
-    send_accumulated_pressure_data = 0x8f,
+    send_accumulated_sensor_data = 0x8f,
     set_hepa_fan_state_request = 0x90,
     get_hepa_fan_state_request = 0x91,
     get_hepa_fan_state_response = 0x92,
@@ -197,6 +197,7 @@ enum class SensorType {
     pressure_temperature = 0x4,
     humidity = 0x5,
     temperature = 0x6,
+    UNUSED = 0x7,
 };
 
 /** Sensor IDs available.
diff --git a/include/can/core/messages.hpp b/include/can/core/messages.hpp
index 2a37a0a85..1e5d5d917 100644
--- a/include/can/core/messages.hpp
+++ b/include/can/core/messages.hpp
@@ -786,24 +786,28 @@ struct FirmwareUpdateStatusResponse
         -> bool = default;
 };
 
-struct SendAccumulatedPressureDataRequest
-    : BaseMessage<MessageId::send_accumulated_pressure_data> {
+struct SendAccumulatedSensorDataRequest
+    : BaseMessage<MessageId::send_accumulated_sensor_data> {
     uint32_t message_index = 0;
     uint8_t sensor_id = 0;
+    uint8_t sensor_type = 0;
 
     template <bit_utils::ByteIterator Input, typename Limit>
     static auto parse(Input body, Limit limit)
-        -> SendAccumulatedPressureDataRequest {
+        -> SendAccumulatedSensorDataRequest {
         uint32_t msg_ind = 0;
         uint8_t sensor_id = 0;
+        uint8_t sensor_type = 0;
 
         body = bit_utils::bytes_to_int(body, limit, msg_ind);
         body = bit_utils::bytes_to_int(body, limit, sensor_id);
-        return SendAccumulatedPressureDataRequest{.message_index = msg_ind,
-                                                  .sensor_id = sensor_id};
+        body = bit_utils::bytes_to_int(body, limit, sensor_type);
+        return SendAccumulatedSensorDataRequest{.message_index = msg_ind,
+                                                  .sensor_id = sensor_id,
+                                                  .sensor_type = sensor_type};
     }
 
-    auto operator==(const SendAccumulatedPressureDataRequest& other) const
+    auto operator==(const SendAccumulatedSensorDataRequest& other) const
         -> bool = default;
 };
 
@@ -1772,6 +1776,7 @@ struct AddSensorMoveRequest : BaseMessage<MessageId::add_sensor_move_request> {
     mm_per_tick velocity;
     uint8_t request_stop_condition;
     can::ids::SensorId sensor_id{};
+    can::ids::SensorType sensor_type{};
 
     template <bit_utils::ByteIterator Input, typename Limit>
     static auto parse(Input body, Limit limit) -> AddSensorMoveRequest {
@@ -1783,6 +1788,7 @@ struct AddSensorMoveRequest : BaseMessage<MessageId::add_sensor_move_request> {
         uint8_t request_stop_condition = 0;
         uint32_t msg_ind = 0;
         uint8_t sensor_id = 0;
+        uint8_t sensor_type = 0;
 
         body = bit_utils::bytes_to_int(body, limit, msg_ind);
         body = bit_utils::bytes_to_int(body, limit, group_id);
@@ -1792,6 +1798,7 @@ struct AddSensorMoveRequest : BaseMessage<MessageId::add_sensor_move_request> {
         body = bit_utils::bytes_to_int(body, limit, velocity);
         body = bit_utils::bytes_to_int(body, limit, request_stop_condition);
         body = bit_utils::bytes_to_int(body, limit, sensor_id);
+        body = bit_utils::bytes_to_int(body, limit, sensor_type);
         return AddSensorMoveRequest{
             .message_index = msg_ind,
             .group_id = group_id,
@@ -1801,6 +1808,7 @@ struct AddSensorMoveRequest : BaseMessage<MessageId::add_sensor_move_request> {
             .velocity = velocity,
             .request_stop_condition = request_stop_condition,
             .sensor_id = static_cast<can::ids::SensorId>(sensor_id),
+            .sensor_type = static_cast<can::ids::SensorType>(sensor_type),
         };
     }
 
diff --git a/include/gripper/core/can_task.hpp b/include/gripper/core/can_task.hpp
index 91e03acc7..0d91017fc 100644
--- a/include/gripper/core/can_task.hpp
+++ b/include/gripper/core/can_task.hpp
@@ -66,7 +66,7 @@ using GripperInfoDispatchTarget = can::dispatch::DispatchParseTarget<
 using SensorDispatchTarget = can::dispatch::DispatchParseTarget<
     sensors::handlers::SensorHandler<gripper_tasks::QueueClient>,
     can::messages::TipStatusQueryRequest, can::messages::ReadFromSensorRequest,
-    can::messages::SendAccumulatedPressureDataRequest,
+    can::messages::SendAccumulatedSensorDataRequest,
     can::messages::WriteToSensorRequest, can::messages::BaselineSensorRequest,
     can::messages::SetSensorThresholdRequest,
     can::messages::BindSensorOutputRequest,
diff --git a/include/motor-control/core/motor_messages.hpp b/include/motor-control/core/motor_messages.hpp
index d012507f5..0f77c5dc7 100644
--- a/include/motor-control/core/motor_messages.hpp
+++ b/include/motor-control/core/motor_messages.hpp
@@ -90,6 +90,7 @@ struct SensorSyncMove {  // NOLINT(cppcoreguidelines-pro-type-member-init)
     int32_t start_encoder_position;
     uint16_t usage_key;
     can::ids::SensorId sensor_id;
+    can::ids::SensorType sensor_type;
 
     auto build_ack(uint32_t position, int32_t pulses, uint8_t flags,
                    AckMessageId _id) -> Ack {
@@ -119,6 +120,7 @@ struct GearMotorMove  // NOLINT(cppcoreguidelines-pro-type-member-init)
     can::ids::PipetteTipActionType action;
     can::ids::GearMotorId gear_motor_id;
     can::ids::SensorId sensor_id;
+    can::ids::SensorType sensor_type;
     auto build_ack(uint32_t position, int32_t pulses, uint8_t flags,
                    AckMessageId _id) -> GearMotorAck {
         return GearMotorAck{message_index, group_id,
diff --git a/include/motor-control/core/stepper_motor/motion_controller.hpp b/include/motor-control/core/stepper_motor/motion_controller.hpp
index b798f136a..0f0203921 100644
--- a/include/motor-control/core/stepper_motor/motion_controller.hpp
+++ b/include/motor-control/core/stepper_motor/motion_controller.hpp
@@ -79,7 +79,8 @@ class MotionController {
             can_msg.request_stop_condition,
             0,
             hardware.get_usage_eeprom_config().get_distance_key(),
-            can_msg.sensor_id};
+            can_msg.sensor_id,
+            can_msg.sensor_type};
         if (!enabled) {
             enable_motor();
         }
@@ -100,7 +101,8 @@ class MotionController {
             .seq_id = can_msg.seq_id,
             .stop_condition = can_msg.request_stop_condition,
             .usage_key = hardware.get_usage_eeprom_config().get_distance_key(),
-            .sensor_id = can::ids::SensorId::UNUSED};
+            .sensor_id = can::ids::SensorId::UNUSED,
+            .sensor_type = can::ids::SensorType::UNUSED};
         if (!enabled) {
             enable_motor();
         }
@@ -120,7 +122,8 @@ class MotionController {
             .stop_condition =
                 static_cast<uint8_t>(MoveStopCondition::limit_switch),
             .usage_key = hardware.get_usage_eeprom_config().get_distance_key(),
-            .sensor_id = can::ids::SensorId::UNUSED};
+            .sensor_id = can::ids::SensorId::UNUSED,
+            .sensor_type = can::ids::SensorType::UNUSED};
         if (!enabled) {
             enable_motor();
         }
@@ -329,7 +332,8 @@ class PipetteMotionController {
             hardware.get_step_tracker(),
             can_msg.action,
             gear_motor_id,
-            can::ids::SensorId::UNUSED};
+            can::ids::SensorId::UNUSED,
+            can::ids::SensorType::UNUSED};
 
         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 2c96cb90c..df84bc496 100644
--- a/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
+++ b/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
@@ -10,9 +10,6 @@
 #include "motor-control/core/stall_check.hpp"
 #include "motor-control/core/tasks/move_status_reporter_task.hpp"
 #include "motor-control/core/tasks/tmc_motor_driver_common.hpp"
-#ifdef USE_SENSOR_MOVE
-#include "pipettes/core/sensor_tasks.hpp"
-#endif
 
 namespace motor_handler {
 
@@ -45,8 +42,28 @@ using namespace motor_messages;
  * Note: The position tracker should never be allowed to go below zero.
  */
 
+// take macros up a level to this?
+//see tabs
+struct Empty {};
+
+template <class SensorClient>
+struct SensorAccessHelper {
+    inline static void send_to_pressure_sensor_queue(SensorClient& sensor_client, can::messages::BindSensorOutputRequest& m) {
+        sensor_client.send_to_pressure_sensor_queue(m); // handle return type/data. use send_to_isr like previously
+    }
+    inline static void send_to_capacitive_sensor_queue(SensorClient& sensor_client, can::messages::BindSensorOutputRequest& m) {
+        sensor_client.send_to_capacitive_sensor_queue(m);
+    }
+}
+
+template<> struct SensorAccessHelper<Empty> {
+    inline static void send_to_pressure_sensor_queue(Empty& sensor_client, can::messages::BindSensorOutputRequest& m) {}
+    inline static void send_to_capacitive_sensor_queue(Empty& sensor_client, can::messages::BindSensorOutputRequest& m) {}
+}
+
 template <template <class> class QueueImpl, class StatusClient,
-          class DriverClient, typename MotorMoveMessage, typename MotorHardware>
+          class DriverClient, typename MotorMoveMessage, typename MotorHardware,
+          class SensorClient = Empty>
 requires MessageQueue<QueueImpl<MotorMoveMessage>, MotorMoveMessage> &&
     std::is_base_of_v<motor_hardware::MotorHardwareIface, MotorHardware>
 class MotorInterruptHandler {
@@ -60,13 +77,15 @@ class MotorInterruptHandler {
                           DriverClient& driver_queue,
                           MotorHardware& hardware_iface,
                           stall_check::StallCheck& stall,
-                          UpdatePositionQueue& incoming_update_position_queue)
+                          UpdatePositionQueue& incoming_update_position_queue,
+                          SensorClient& sensor_queue_client) // make optional, default nullopt
         : move_queue(incoming_move_queue),
           status_queue_client(outgoing_queue),
           driver_client(driver_queue),
           hardware(hardware_iface),
           stall_checker{stall},
-          update_position_queue(incoming_update_position_queue) {
+          update_position_queue(incoming_update_position_queue),
+          sensor_client(sensor_client) {
         hardware.unstep();
     }
     ~MotorInterruptHandler() = default;
@@ -388,13 +407,23 @@ class MotorInterruptHandler {
                 hardware.get_encoder_pulses();
 #ifdef USE_SENSOR_MOVE
             if (buffered_move.sensor_id != can::ids::SensorId::UNUSED) {
-                auto msg = can::messages::BindSensorOutputRequest{
-                    .message_index = buffered_move.message_index,
-                    .sensor = can::ids::SensorType::pressure,
-                    .sensor_id = buffered_move.sensor_id,
-                    .binding = static_cast<uint8_t>(0x3)  // sync and report
-                };
-                send_to_pressure_sensor_queue(msg);
+                if (buffered_move.sensor_type == can::ids::SensorType::pressure) {
+                    auto msg = can::messages::BindSensorOutputRequest{
+                        .message_index = buffered_move.message_index,
+                        .sensor = can::ids::SensorType::pressure,
+                        .sensor_id = buffered_move.sensor_id,
+                        .binding = static_cast<uint8_t>(0x3)  // sync and report
+                    };
+                    send_to_pressure_sensor_queue(msg);
+                } else if (buffered_move.sensor_type == can::ids::SensorType::capacitive) {
+                    auto msg = can::messages::BindSensorOutputRequest{
+                        .message_index = buffered_move.message_index,
+                        .sensor = can::ids::SensorType::capacitive,
+                        .sensor_id = buffered_move.sensor_id,
+                        .binding = static_cast<uint8_t>(0x3)  // sync and report
+                    };
+                    send_to_capacitive_sensor_queue(msg);
+                }
             }
 #endif
         }
@@ -486,13 +515,23 @@ class MotorInterruptHandler {
         build_and_send_ack(ack_msg_id);
 #ifdef USE_SENSOR_MOVE
         if (buffered_move.sensor_id != can::ids::SensorId::UNUSED) {
-            auto stop_msg = can::messages::BindSensorOutputRequest{
-                .message_index = buffered_move.message_index,
-                .sensor = can::ids::SensorType::pressure,
-                .sensor_id = buffered_move.sensor_id,
-                .binding =
-                    static_cast<uint8_t>(can::ids::SensorOutputBinding::sync)};
-            send_to_pressure_sensor_queue(stop_msg);
+            if (buffered_move.sensor_type == can::ids::SensorType::pressure) {
+                auto stop_msg = can::messages::BindSensorOutputRequest{
+                    .message_index = buffered_move.message_index,
+                    .sensor = can::ids::SensorType::pressure,
+                    .sensor_id = buffered_move.sensor_id,
+                    .binding =
+                        static_cast<uint8_t>(can::ids::SensorOutputBinding::sync)};
+                send_to_pressure_sensor_queue(stop_msg);
+            } else if (buffered_move.sensor_type == can::ids::SensorType::pressure) {
+                auto stop_msg = can::messages::BindSensorOutputRequest{
+                    .message_index = buffered_move.message_index,
+                    .sensor = can::ids::SensorType::capacitive,
+                    .sensor_id = buffered_move.sensor_id,
+                    .binding =
+                        static_cast<uint8_t>(can::ids::SensorOutputBinding::sync)};
+                send_to_capacitive_sensor_queue(stop_msg);
+            }
         }
 #endif
         set_buffered_move(MotorMoveMessage{});
@@ -640,9 +679,11 @@ class MotorInterruptHandler {
 #ifdef USE_SENSOR_MOVE
     void send_to_pressure_sensor_queue(
         can::messages::BindSensorOutputRequest& m) {
-        std::ignore = sensor_tasks::get_queues()
-                          .pressure_sensor_queue_rear->try_write_isr(m);
-        // if (!success) {this->cancel_and_clear_moves();}
+        SensorClientHelper<SensorClient>::send_to_pressure_sensor_queue(sensor_client, m);
+    }
+    void send_to_capacitive_sensor_queue(
+        can::messages::BindSensorOutputRequest& m) {
+        SensorClientHelper<SensorClient>::send_to_capacitive_sensor_queue(sensor_client, m);
     }
 #endif
     uint64_t tick_count = 0x0;
@@ -656,6 +697,7 @@ class MotorInterruptHandler {
     MotorHardware& hardware;
     stall_check::StallCheck& stall_checker;
     UpdatePositionQueue& update_position_queue;
+    SensorClient& sensor_client;
     MotorMoveMessage buffered_move = MotorMoveMessage{};
     bool clear_queue_until_empty = false;
     bool stall_handled = false;
diff --git a/include/pipettes/core/dispatch_builder.hpp b/include/pipettes/core/dispatch_builder.hpp
index 87e0123b8..7c82b97f7 100644
--- a/include/pipettes/core/dispatch_builder.hpp
+++ b/include/pipettes/core/dispatch_builder.hpp
@@ -95,7 +95,7 @@ using SystemDispatchTarget = can::dispatch::DispatchParseTarget<
 using SensorDispatchTarget = can::dispatch::DispatchParseTarget<
     sensors::handlers::SensorHandler<sensor_tasks::QueueClient>,
     can::messages::TipStatusQueryRequest, can::messages::ReadFromSensorRequest,
-    can::messages::SendAccumulatedPressureDataRequest,
+    can::messages::SendAccumulatedSensorDataRequest,
     can::messages::WriteToSensorRequest, can::messages::BaselineSensorRequest,
     can::messages::SetSensorThresholdRequest,
     can::messages::BindSensorOutputRequest,
diff --git a/include/pipettes/core/motor_interrupt_handler.hpp b/include/pipettes/core/motor_interrupt_handler.hpp
deleted file mode 100644
index f625f1a13..000000000
--- a/include/pipettes/core/motor_interrupt_handler.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-
-#include "motor-control/core/stepper_motor/motor_interrupt_handler.hpp"
-#include "pipettes/core/sensor_tasks.hpp"
-
-namespace pipettes {
-using namespace motor_messages;
-template <template <class> class QueueImpl, class StatusClient,
-          class DriverClient, typename MotorMoveMessage, typename MotorHardware,
-          class SensorClient>
-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,
-          DriverClient, MotorMoveMessage, MotorHardware> {
-  public:
-    using MoveQueue = QueueImpl<MotorMoveMessage>;
-    using UpdatePositionQueue =
-        QueueImpl<can::messages::UpdateMotorPositionEstimationRequest>;
-    PipetteMotorInterruptHandler() = delete;
-    PipetteMotorInterruptHandler(
-        MoveQueue& incoming_move_queue, StatusClient& outgoing_queue,
-        DriverClient& driver_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,
-              DriverClient, MotorMoveMessage, MotorHardware>(
-              incoming_move_queue, outgoing_queue, driver_queue, hardware_iface,
-              stall, incoming_update_position_queue),
-          sensor_client(sensor_queue_client) {}
-
-    ~PipetteMotorInterruptHandler() = default;
-
-    auto operator=(PipetteMotorInterruptHandler&)
-        -> PipetteMotorInterruptHandler& = delete;
-
-    auto operator=(PipetteMotorInterruptHandler&&)
-        -> PipetteMotorInterruptHandler&& = delete;
-
-    PipetteMotorInterruptHandler(PipetteMotorInterruptHandler&) = delete;
-
-    PipetteMotorInterruptHandler(PipetteMotorInterruptHandler&&) = delete;
-
-  private:
-    SensorClient& sensor_client;
-};
-}  // namespace pipettes
\ No newline at end of file
diff --git a/include/pipettes/firmware/interfaces.hpp b/include/pipettes/firmware/interfaces.hpp
index 71e15a805..52a1cd923 100644
--- a/include/pipettes/firmware/interfaces.hpp
+++ b/include/pipettes/firmware/interfaces.hpp
@@ -8,6 +8,7 @@
 #include "pipettes/core/linear_motor_tasks.hpp"
 #include "pipettes/core/motor_configurations.hpp"
 #include "pipettes/core/pipette_type.h"
+#include "pipettes/core/sensor_tasks.hpp"
 
 #pragma GCC diagnostic push
 // NOLINTNEXTLINE(clang-diagnostic-unknown-warning-option)
@@ -22,17 +23,20 @@ namespace interfaces {
 template <typename Client, typename DriverClient>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
-    motor_messages::SensorSyncMove, motor_hardware::MotorHardware>;
+    motor_messages::SensorSyncMove, motor_hardware::MotorHardware,
+    sensor_tasks::QueueClient>;
 #else
 template <typename Client, typename DriverClient>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
-    motor_messages::Move, motor_hardware::MotorHardware>;
+    motor_messages::Move, motor_hardware::MotorHardware,
+    sensor_tasks::QueueClient>;
 #endif
 template <typename Client>
 using GearMotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, Client,
-    motor_messages::GearMotorMove, motor_hardware::MotorHardware>;
+    motor_messages::GearMotorMove, motor_hardware::MotorHardware,
+    sensor_tasks::QueueClient>;
 
 template <PipetteType P>
 auto get_interrupt_queues()
@@ -73,13 +77,15 @@ namespace linear_motor {
 
 auto get_interrupt(motor_hardware::MotorHardware& hw,
                    LowThroughputInterruptQueues& queues,
-                   stall_check::StallCheck& stall)
+                   stall_check::StallCheck& stall,
+                   sensor_tasks::QueueClient& sensor_client)
     -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2130_driver::QueueClient>;
 auto get_interrupt(motor_hardware::MotorHardware& hw,
                    HighThroughputInterruptQueues& queues,
-                   stall_check::StallCheck& stall)
+                   stall_check::StallCheck& stall,
+                   sensor_tasks::QueueClient& sensor_client)
     -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2160_driver::QueueClient>;
diff --git a/include/pipettes/firmware/interfaces_g4.hpp b/include/pipettes/firmware/interfaces_g4.hpp
index eb33366c0..5054799a3 100644
--- a/include/pipettes/firmware/interfaces_g4.hpp
+++ b/include/pipettes/firmware/interfaces_g4.hpp
@@ -8,8 +8,8 @@
 #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"
+#include "pipettes/core/sensor_tasks.hpp"
 
 #pragma GCC diagnostic push
 // NOLINTNEXTLINE(clang-diagnostic-unknown-warning-option)
@@ -31,20 +31,12 @@ namespace interfaces {
 #ifdef USE_SENSOR_MOVE
 template <typename Client, typename DriverClient>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
-    motor_messages::SensorSyncMove, motor_hardware::MotorHardware>;
-template <typename Client, typename DriverClient>
-using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
     motor_messages::SensorSyncMove, motor_hardware::MotorHardware,
     sensor_tasks::QueueClient>;
 #else
 template <typename Client, typename DriverClient>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
-    motor_messages::Move, motor_hardware::MotorHardware>;
-template <typename Client, typename DriverClient>
-using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, DriverClient,
     motor_messages::Move, motor_hardware::MotorHardware,
     sensor_tasks::QueueClient>;
@@ -52,7 +44,8 @@ using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
 template <typename Client>
 using GearMotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, Client,
-    motor_messages::GearMotorMove, motor_hardware::MotorHardware>;
+    motor_messages::GearMotorMove, motor_hardware::MotorHardware,
+    sensor_tasks::QueueClient>;
 
 template <PipetteType P>
 auto get_interrupt_queues()
@@ -95,14 +88,14 @@ auto get_interrupt(motor_hardware::MotorHardware& hw,
                    LowThroughputInterruptQueues& queues,
                    stall_check::StallCheck& stall,
                    sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<
+    -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2130_driver::QueueClient>;
 auto get_interrupt(motor_hardware::MotorHardware& hw,
                    HighThroughputInterruptQueues& queues,
                    stall_check::StallCheck& stall,
                    sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<
+    -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2160_driver::QueueClient>;
 auto get_motor_hardware(motor_hardware::HardwareConfig pins)
diff --git a/include/sensors/core/message_handlers/sensors.hpp b/include/sensors/core/message_handlers/sensors.hpp
index e888815fe..1dd995330 100644
--- a/include/sensors/core/message_handlers/sensors.hpp
+++ b/include/sensors/core/message_handlers/sensors.hpp
@@ -46,9 +46,14 @@ class SensorHandler {
                       can::ids::SensorId(m.sensor_id), m);
     }
 
-    void visit(const can::messages::SendAccumulatedPressureDataRequest &m) {
-        send_to_queue(can::ids::SensorType::pressure,
+    void visit(const can::messages::SendAccumulatedSensorDataRequest &m) {
+        if (can::ids::SensorType(m.sensor_type) == can::ids::SensorType::pressure) {
+            send_to_queue(can::ids::SensorType::pressure,
                       can::ids::SensorId(m.sensor_id), m);
+        } else if (can::ids::SensorType(m.sensor_type) == can::ids::SensorType::capacitive) {
+            send_to_queue(can::ids::SensorType::capacitive,
+                      can::ids::SensorId(m.sensor_id), m);
+        }
     }
 
     void visit(const can::messages::BindSensorOutputRequest &m) {
diff --git a/include/sensors/core/tasks/capacitive_sensor_task.hpp b/include/sensors/core/tasks/capacitive_sensor_task.hpp
index f7416b9d7..482a2a4ba 100644
--- a/include/sensors/core/tasks/capacitive_sensor_task.hpp
+++ b/include/sensors/core/tasks/capacitive_sensor_task.hpp
@@ -65,9 +65,10 @@ class CapacitiveMessageHandler {
         }
     }
 
-    void visit(const can::messages::SendAccumulatedPressureDataRequest &m) {
-        LOG("Received request to dump pressure data buffer %d", m.sensor_id);
-        std::ignore = m;
+    void visit(const can::messages::SendAccumulatedSensorDataRequest &m) {
+        LOG("Received request to dump capacitive data buffer %d", m.sensor_id);
+        
+        driver.send_accumulated_sensor_data(m.message_index);
     }
 
     void visit(can::messages::ReadFromSensorRequest &m) {
diff --git a/include/sensors/core/tasks/environmental_sensor_task.hpp b/include/sensors/core/tasks/environmental_sensor_task.hpp
index ec641fbe6..57b272a3e 100644
--- a/include/sensors/core/tasks/environmental_sensor_task.hpp
+++ b/include/sensors/core/tasks/environmental_sensor_task.hpp
@@ -75,8 +75,8 @@ class EnvironmentSensorMessageHandler {
         driver.trigger_on_demand();
     }
 
-    void visit(const can::messages::SendAccumulatedPressureDataRequest &m) {
-        LOG("Received request to dump pressure data buffer %d", m.sensor_id);
+    void visit(const can::messages::SendAccumulatedSensorDataRequest &m) {
+        LOG("Received request to dump environmental data buffer %d", m.sensor_id);
         std::ignore = m;
     }
 
diff --git a/include/sensors/core/tasks/pressure_driver.hpp b/include/sensors/core/tasks/pressure_driver.hpp
index 393493e5d..0551e765f 100644
--- a/include/sensors/core/tasks/pressure_driver.hpp
+++ b/include/sensors/core/tasks/pressure_driver.hpp
@@ -15,9 +15,9 @@
 #include "sensors/core/utils.hpp"
 
 #if defined(USE_SENSOR_MOVE)
-constexpr size_t PRESSURE_SENSOR_BUFFER_SIZE = P_BUFF_SIZE;
+constexpr size_t SENSOR_BUFFER_SIZE = P_BUFF_SIZE;
 #else
-constexpr size_t PRESSURE_SENSOR_BUFFER_SIZE = 0;
+constexpr size_t SENSOR_BUFFER_SIZE = 0;
 #endif
 
 namespace sensors {
@@ -43,7 +43,7 @@ class MMR920 {
            sensors::hardware::SensorHardwareBase &hardware,
            const can::ids::SensorId &id,
            const sensors::mmr920::SensorVersion version,
-           std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> *p_buff)
+           std::array<float, SENSOR_BUFFER_SIZE> *p_buff)
         : writer(writer),
           poller(poller),
           can_client(can_client),
@@ -284,7 +284,7 @@ class MMR920 {
             mmr920::ADDRESS, reg_id, 3, STOP_DELAY, own_queue, transaction_id);
     }
 
-    void send_accumulated_pressure_data(uint32_t message_index) {
+    void send_accumulated_sensor_data(uint32_t message_index) {
 #ifdef USE_SENSOR_MOVE
         for (int i = 0; i < pressure_buffer_index; i++) {
             // send over buffer adn then clear buffer values
@@ -367,7 +367,7 @@ class MMR920 {
 #ifdef USE_SENSOR_MOVE
             // send a response with 9999 to make an overload of the buffer
             // visible
-            if (pressure_buffer_index < PRESSURE_SENSOR_BUFFER_SIZE) {
+            if (pressure_buffer_index < SENSOR_BUFFER_SIZE) {
                 (*p_buff).at(pressure_buffer_index) = pressure;
                 pressure_buffer_index++;
             } else {
@@ -566,7 +566,7 @@ class MMR920 {
         value &= Reg::value_mask;
         return write(Reg::address, value);
     }
-    std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> *p_buff;
+    std::array<float, SENSOR_BUFFER_SIZE> *p_buff;
     uint16_t pressure_buffer_index = 0;
 };
 
diff --git a/include/sensors/core/tasks/pressure_sensor_task.hpp b/include/sensors/core/tasks/pressure_sensor_task.hpp
index c17a44770..a8ef5f6db 100644
--- a/include/sensors/core/tasks/pressure_sensor_task.hpp
+++ b/include/sensors/core/tasks/pressure_sensor_task.hpp
@@ -24,7 +24,7 @@ class PressureMessageHandler {
         sensors::hardware::SensorHardwareBase &hardware,
         const can::ids::SensorId &id,
         const sensors::mmr920::SensorVersion &version,
-        std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> *p_buff)
+        std::array<float, SENSOR_BUFFER_SIZE> *p_buff)
         : driver{i2c_writer, i2c_poller, can_client, own_queue,
                  hardware,   id,         version,    p_buff} {}
     PressureMessageHandler(const PressureMessageHandler &) = delete;
@@ -79,10 +79,10 @@ class PressureMessageHandler {
         }
     }
 
-    void visit(const can::messages::SendAccumulatedPressureDataRequest &m) {
+    void visit(const can::messages::SendAccumulatedSensorDataRequest &m) {
         LOG("Received request to dump pressure data buffer");
 
-        driver.send_accumulated_pressure_data(m.message_index);
+        driver.send_accumulated_sensor_data(m.message_index);
     }
 
     void visit(const can::messages::ReadFromSensorRequest &m) {
@@ -204,7 +204,7 @@ class PressureSensorTask {
         i2c::poller::Poller<QueueImpl> *poller, CanClient *can_client,
         sensors::hardware::SensorHardwareBase *hardware,
         sensors::mmr920::SensorVersion *sensor_version,
-        std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> *p_buff) {
+        std::array<float, SENSOR_BUFFER_SIZE> *p_buff) {
         auto handler = PressureMessageHandler{
             *writer,   *poller,   *can_client,     get_queue(),
             *hardware, sensor_id, *sensor_version, p_buff};
diff --git a/include/sensors/core/utils.hpp b/include/sensors/core/utils.hpp
index e7bffe187..ad16499f6 100644
--- a/include/sensors/core/utils.hpp
+++ b/include/sensors/core/utils.hpp
@@ -20,7 +20,7 @@ namespace utils {
 
 using CanMessageTuple =
     std::tuple<can::messages::ReadFromSensorRequest,
-               can::messages::SendAccumulatedPressureDataRequest,
+               can::messages::SendAccumulatedSensorDataRequest,
                can::messages::WriteToSensorRequest,
                can::messages::BaselineSensorRequest,
                can::messages::SetSensorThresholdRequest,
diff --git a/pipettes/core/sensor_tasks.cpp b/pipettes/core/sensor_tasks.cpp
index db6855e1b..c160a3d00 100644
--- a/pipettes/core/sensor_tasks.cpp
+++ b/pipettes/core/sensor_tasks.cpp
@@ -6,7 +6,7 @@
 
 static auto tasks = sensor_tasks::Tasks{};
 static auto queue_client = sensor_tasks::QueueClient{};
-static std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> p_buff;
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff;
 static auto eeprom_task_builder =
     freertos_task::TaskStarter<512, eeprom::task::EEPromTask>{};
 
diff --git a/pipettes/firmware/interfaces.cpp b/pipettes/firmware/interfaces.cpp
index 5a73204b1..50db1cbd9 100644
--- a/pipettes/firmware/interfaces.cpp
+++ b/pipettes/firmware/interfaces.cpp
@@ -59,10 +59,10 @@ auto linear_motor::get_interrupt(motor_hardware::MotorHardware& hw,
                                  LowThroughputInterruptQueues& queues,
                                  stall_check::StallCheck& stall,
                                  sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<
+    -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2130_driver::QueueClient> {
-    return pipettes::PipetteMotorInterruptHandler(
+    return motor_handler::MotorInterruptHandler(
         queues.plunger_queue, linear_motor_tasks::get_queues(),
         linear_motor_tasks::tmc2130_driver::get_queues(), hw, stall,
         queues.plunger_update_queue, sensor_client);
@@ -72,10 +72,10 @@ auto linear_motor::get_interrupt(motor_hardware::MotorHardware& hw,
                                  HighThroughputInterruptQueues& queues,
                                  stall_check::StallCheck& stall,
                                  sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<
+    -> MotorInterruptHandlerType<
         linear_motor_tasks::QueueClient,
         linear_motor_tasks::tmc2160_driver::QueueClient> {
-    return pipettes::PipetteMotorInterruptHandler(
+    return motor_handler::MotorInterruptHandler(
         queues.plunger_queue, linear_motor_tasks::get_queues(),
         linear_motor_tasks::tmc2160_driver::get_queues(), hw, stall,
         queues.plunger_update_queue, sensor_client);
@@ -140,11 +140,11 @@ auto gear_motor::get_interrupts(gear_motor::GearHardware& hw,
         .left = motor_handler::MotorInterruptHandler(
             queues.left_motor_queue, gear_motor_tasks::get_left_gear_queues(),
             gear_motor_tasks::get_left_gear_queues(), hw.left, stall.left,
-            queues.left_update_queue),
+            queues.left_update_queue, nullptr), //make SensorMotorInterruptHandler
         .right = motor_handler::MotorInterruptHandler(
             queues.right_motor_queue, gear_motor_tasks::get_right_gear_queues(),
             gear_motor_tasks::get_right_gear_queues(), hw.right, stall.right,
-            queues.right_update_queue)};
+            queues.right_update_queue, nullptr)};
 }
 
 auto gear_motor::get_interrupts(gear_motor::UnavailableGearHardware&,
diff --git a/sensors/tests/test_pressure_driver.cpp b/sensors/tests/test_pressure_driver.cpp
index b0ca920da..a1570b32c 100644
--- a/sensors/tests/test_pressure_driver.cpp
+++ b/sensors/tests/test_pressure_driver.cpp
@@ -38,7 +38,7 @@ auto get_message(Queue& q) -> Message {
 
 constexpr auto sensor_id = can::ids::SensorId::S0;
 constexpr uint8_t sensor_id_int = 0x0;
-static std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> p_buff;
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff;
 
 SCENARIO("Testing the pressure sensor driver") {
     test_mocks::MockMessageQueue<i2c::writer::TaskMessage> i2c_queue{};
diff --git a/sensors/tests/test_pressure_sensor.cpp b/sensors/tests/test_pressure_sensor.cpp
index c0d02e8b7..5a5aae5d0 100644
--- a/sensors/tests/test_pressure_sensor.cpp
+++ b/sensors/tests/test_pressure_sensor.cpp
@@ -36,7 +36,7 @@ constexpr uint8_t pressure_temperature_id =
     static_cast<uint8_t>(can::ids::SensorType::pressure_temperature);
 constexpr uint8_t sensor_id_int = 0x0;
 
-static std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> p_buff;
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff;
 
 SCENARIO("Receiving messages through the pressure sensor message handler") {
     test_mocks::MockMessageQueue<i2c::writer::TaskMessage> i2c_queue{};