diff --git a/.github/workflows/cross-compile-special-sensors.yaml b/.github/workflows/cross-compile-special-sensors.yaml
index ff1038851..355e067ac 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/CMakePresets.json b/CMakePresets.json
index 6dbf1c62d..44b3d417d 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -42,7 +42,7 @@
       "installDir": "${sourceDir}/dist-sensor",
       "binaryDir": "${sourceDir}/build-cross-sensor",
       "cacheVariables": {
-        "USE_PRESSURE_MOVE": true
+        "USE_SENSOR_MOVE": true
       },
       "inherits": "cross"
     },
diff --git a/common/core/CMakeLists.txt b/common/core/CMakeLists.txt
index 2cb65af42..1f6564e5a 100644
--- a/common/core/CMakeLists.txt
+++ b/common/core/CMakeLists.txt
@@ -54,7 +54,7 @@ function(add_revision)
   message(STATUS "add_revision has target ${_ar_TARGET} and revision ${_ar_REVISION}")
   string(SUBSTRING ${_ar_REVISION} 0 1 PRIMARY_REVISION)
   string(SUBSTRING ${_ar_REVISION} 1 1 SECONDARY_REVISION)
-  if (${USE_PRESSURE_MOVE})
+  if (${USE_SENSOR_MOVE})
   set(TERTIARY_FLAG "'1'")
   else()
   set(TERTIARY_FLAG "0x00")
diff --git a/gripper/core/CMakeLists.txt b/gripper/core/CMakeLists.txt
index fb8705cbf..9089fc917 100644
--- a/gripper/core/CMakeLists.txt
+++ b/gripper/core/CMakeLists.txt
@@ -1,4 +1,9 @@
 function(target_gripper_core TARGET)
+    if(${USE_SENSOR_MOVE})
+    target_compile_definitions(${TARGET} PUBLIC USE_SENSOR_MOVE)
+    target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=1700)
+    target_compile_definitions(${TARGET} PUBLIC USE_TWO_BUFFERS=true)
+    endif()
     target_sources(${TARGET} PUBLIC
             ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/can_tasks.cpp
             ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/tasks.cpp
diff --git a/gripper/core/tasks.cpp b/gripper/core/tasks.cpp
index cd16770c6..da192c96d 100644
--- a/gripper/core/tasks.cpp
+++ b/gripper/core/tasks.cpp
@@ -16,6 +16,10 @@
 
 static auto tasks = gripper_tasks::AllTask{};
 static auto queues = gripper_tasks::QueueClient{can::ids::NodeId::gripper};
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff;
+#ifdef USE_TWO_BUFFERS
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff_front;
+#endif
 
 static auto eeprom_task_builder =
     freertos_task::TaskStarter<512, eeprom::task::EEPromTask>{};
@@ -95,11 +99,16 @@ void gripper_tasks::start_tasks(
     auto& capacitive_sensor_task_front =
         capacitive_sensor_task_builder_front.start(
             5, "cap sensor S1", i2c2_task_client, i2c2_poll_client,
-            sensor_hardware, queues);
+            sensor_hardware, queues,
+#ifdef USE_TWO_BUFFERS
+            p_buff_front);
+#else
+            p_buff);
+#endif
     auto& capacitive_sensor_task_rear =
         capacitive_sensor_task_builder_rear.start(
             5, "cap sensor S0", i2c3_task_client, i2c3_poll_client,
-            sensor_hardware, queues);
+            sensor_hardware, queues, p_buff);
 
     tasks.i2c2_task = &i2c2_task;
     tasks.i2c3_task = &i2c3_task;
@@ -152,6 +161,16 @@ void gripper_tasks::QueueClient::send_capacitive_sensor_queue_rear(
     capacitive_sensor_queue_rear->try_write(m);
 }
 
+void gripper_tasks::QueueClient::send_capacitive_sensor_queue_front_isr(
+    const sensors::utils::TaskMessage& m) {
+    std::ignore = capacitive_sensor_queue_front->try_write_isr(m);
+}
+
+void gripper_tasks::QueueClient::send_capacitive_sensor_queue_rear_isr(
+    const sensors::utils::TaskMessage& m) {
+    std::ignore = capacitive_sensor_queue_rear->try_write_isr(m);
+}
+
 // gripper does not have environment nor pressure sensor
 void gripper_tasks::QueueClient::send_environment_sensor_queue(
     const sensors::utils::TaskMessage&) {}
@@ -159,6 +178,10 @@ void gripper_tasks::QueueClient::send_pressure_sensor_queue_front(
     const sensors::utils::TaskMessage&) {}
 void gripper_tasks::QueueClient::send_pressure_sensor_queue_rear(
     const sensors::utils::TaskMessage&) {}
+void gripper_tasks::QueueClient::send_pressure_sensor_queue_front_isr(
+    const sensors::utils::TaskMessage&) {}
+void gripper_tasks::QueueClient::send_pressure_sensor_queue_rear_isr(
+    const sensors::utils::TaskMessage&) {}
 
 void gripper_tasks::QueueClient::send_tip_notification_queue_rear(
     const sensors::tip_presence::TaskMessage&) {}
@@ -176,3 +199,7 @@ auto gripper_tasks::get_all_tasks() -> AllTask& { return tasks; }
  * @return
  */
 auto gripper_tasks::get_main_queues() -> QueueClient& { return queues; }
+
+auto sensor_tasks::get_queues() -> gripper_tasks::QueueClient& {
+    return queues;
+}
diff --git a/gripper/firmware/interfaces_z_motor.cpp b/gripper/firmware/interfaces_z_motor.cpp
index c9c43c9a9..69405dfde 100644
--- a/gripper/firmware/interfaces_z_motor.cpp
+++ b/gripper/firmware/interfaces_z_motor.cpp
@@ -150,8 +150,14 @@ static tmc2130::configs::TMC2130DriverConfig MotorDriverConfigurations{
 /**
  * The pending move queue
  */
+#ifdef USE_SENSOR_MOVE
+static freertos_message_queue::FreeRTOSMessageQueue<
+    motor_messages::SensorSyncMove>
+    motor_queue("Motor Queue");
+#else
 static freertos_message_queue::FreeRTOSMessageQueue<motor_messages::Move>
     motor_queue("Motor Queue");
+#endif
 
 static freertos_message_queue::FreeRTOSMessageQueue<
     can::messages::UpdateMotorPositionEstimationRequest>
diff --git a/include/bootloader/core/ids.h b/include/bootloader/core/ids.h
index b3c7ae1b9..10e6078b9 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 dad0695f5..8bcee3c42 100644
--- a/include/can/core/ids.hpp
+++ b/include/can/core/ids.hpp
@@ -116,7 +116,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,
@@ -193,6 +193,7 @@ enum class SensorType {
     pressure_temperature = 0x4,
     humidity = 0x5,
     temperature = 0x6,
+    UNUSED = 0x7,
 };
 
 /** Sensor IDs available.
diff --git a/include/can/core/message_handlers/move_group.hpp b/include/can/core/message_handlers/move_group.hpp
index b29d54fce..55b5f2492 100644
--- a/include/can/core/message_handlers/move_group.hpp
+++ b/include/can/core/message_handlers/move_group.hpp
@@ -11,7 +11,7 @@ using namespace can::messages;
 template <move_group_task::TaskClient Client>
 class MoveGroupHandler {
   public:
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
     using MessageType =
         std::variant<std::monostate, AddLinearMoveRequest,
                      ClearAllMoveGroupsRequest, ExecuteMoveGroupRequest,
diff --git a/include/can/core/messages.hpp b/include/can/core/messages.hpp
index a60eedc3c..bb9bb6ada 100644
--- a/include/can/core/messages.hpp
+++ b/include/can/core/messages.hpp
@@ -751,24 +751,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;
 };
 
@@ -1737,6 +1741,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 {
@@ -1748,6 +1753,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);
@@ -1757,6 +1763,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,
@@ -1766,6 +1773,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/common/core/sensor_buffer.hpp b/include/common/core/sensor_buffer.hpp
new file mode 100644
index 000000000..978d86cca
--- /dev/null
+++ b/include/common/core/sensor_buffer.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+#ifdef USE_SENSOR_MOVE
+constexpr size_t SENSOR_BUFFER_SIZE = P_BUFF_SIZE;
+#else
+constexpr size_t SENSOR_BUFFER_SIZE = 0;
+#endif
diff --git a/include/gripper/core/can_task.hpp b/include/gripper/core/can_task.hpp
index 88fd98ca2..e3b3f294c 100644
--- a/include/gripper/core/can_task.hpp
+++ b/include/gripper/core/can_task.hpp
@@ -19,12 +19,22 @@ using MotorDispatchTarget = can::dispatch::DispatchParseTarget<
     can::messages::ReadMotorDriverRegister,
     can::messages::WriteMotorDriverRegister,
     can::messages::WriteMotorCurrentRequest>;
+#ifdef USE_SENSOR_MOVE
+using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
+    can::message_handlers::move_group::MoveGroupHandler<z_tasks::QueueClient>,
+    can::messages::AddLinearMoveRequest,
+    can::messages::ClearAllMoveGroupsRequest,
+    can::messages::ExecuteMoveGroupRequest, can::messages::GetMoveGroupRequest,
+    can::messages::HomeRequest, can::messages::StopRequest,
+    can::messages::AddSensorMoveRequest>;
+#else
 using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
     can::message_handlers::move_group::MoveGroupHandler<z_tasks::QueueClient>,
     can::messages::AddLinearMoveRequest,
     can::messages::ClearAllMoveGroupsRequest,
     can::messages::ExecuteMoveGroupRequest, can::messages::GetMoveGroupRequest,
     can::messages::HomeRequest, can::messages::StopRequest>;
+#endif
 using MotionControllerDispatchTarget = can::dispatch::DispatchParseTarget<
     can::message_handlers::motion::MotionHandler<z_tasks::QueueClient>,
     can::messages::DisableMotorRequest, can::messages::EnableMotorRequest,
@@ -65,7 +75,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/gripper/core/tasks.hpp b/include/gripper/core/tasks.hpp
index 74d58a7ea..c61ef164b 100644
--- a/include/gripper/core/tasks.hpp
+++ b/include/gripper/core/tasks.hpp
@@ -67,11 +67,24 @@ struct QueueClient : can::message_writer::MessageWriter {
     void send_capacitive_sensor_queue_rear(
         const sensors::utils::TaskMessage& m);
 
+    void send_capacitive_sensor_queue_front_isr(
+        const sensors::utils::TaskMessage& m);
+
+    void send_capacitive_sensor_queue_rear_isr(
+        const sensors::utils::TaskMessage& m);
+
     void send_environment_sensor_queue(const sensors::utils::TaskMessage& m);
 
     void send_pressure_sensor_queue_front(const sensors::utils::TaskMessage& m);
+
     void send_pressure_sensor_queue_rear(const sensors::utils::TaskMessage& m);
 
+    void send_pressure_sensor_queue_front_isr(
+        const sensors::utils::TaskMessage& m);
+
+    void send_pressure_sensor_queue_rear_isr(
+        const sensors::utils::TaskMessage& m);
+
     void send_tip_notification_queue_rear(
         const sensors::tip_presence::TaskMessage& m);
     void send_tip_notification_queue_front(
@@ -258,3 +271,7 @@ struct QueueClient : can::message_writer::MessageWriter {
 }  // namespace g_tasks
 
 }  // namespace gripper_tasks
+
+namespace sensor_tasks {
+[[nodiscard]] auto get_queues() -> gripper_tasks::QueueClient&;
+}  // namespace sensor_tasks
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 78d6d9006..9cd1e9c4f 100644
--- a/include/motor-control/core/stepper_motor/motion_controller.hpp
+++ b/include/motor-control/core/stepper_motor/motion_controller.hpp
@@ -25,7 +25,7 @@ template <lms::MotorMechanicalConfig MEConfig>
 class MotionController {
   public:
     using GenericQueue =
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
         freertos_message_queue::FreeRTOSMessageQueue<SensorSyncMove>;
 #else
         freertos_message_queue::FreeRTOSMessageQueue<Move>;
@@ -63,7 +63,7 @@ class MotionController {
         -> const lms::LinearMotionSystemConfig<MEConfig>& {
         return linear_motion_sys_config;
     }
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
     void move(const can::messages::AddSensorMoveRequest& can_msg) {
         steps_per_tick velocity_steps =
             fixed_point_multiply(steps_per_mm, can_msg.velocity);
@@ -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();
         }
@@ -318,7 +321,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.hpp b/include/motor-control/core/stepper_motor/motor.hpp
index 20b111fef..b9ff17ee6 100644
--- a/include/motor-control/core/stepper_motor/motor.hpp
+++ b/include/motor-control/core/stepper_motor/motor.hpp
@@ -18,7 +18,11 @@ using namespace freertos_message_queue;
 
 template <lms::MotorMechanicalConfig MEConfig>
 struct Motor {
+#ifdef USE_SENSOR_MOVE
+    using GenericQueue = FreeRTOSMessageQueue<SensorSyncMove>;
+#else
     using GenericQueue = FreeRTOSMessageQueue<Move>;
+#endif
     using UpdatePositionQueue = FreeRTOSMessageQueue<
         can::messages::UpdateMotorPositionEstimationRequest>;
 
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 01cb4e881..577d1cb41 100644
--- a/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
+++ b/include/motor-control/core/stepper_motor/motor_interrupt_handler.hpp
@@ -9,9 +9,14 @@
 #include "motor-control/core/motor_messages.hpp"
 #include "motor-control/core/stall_check.hpp"
 #include "motor-control/core/tasks/move_status_reporter_task.hpp"
-#ifdef USE_PRESSURE_MOVE
+#include "motor-control/core/tasks/tmc_motor_driver_common.hpp"
+#ifdef USE_SENSOR_MOVE
+#ifdef PIPETTE_TYPE_DEFINE
 #include "pipettes/core/sensor_tasks.hpp"
-#endif
+#else
+#include "gripper/core/tasks.hpp"
+#endif  // PIPETTE_TYPE_DEFINE
+#endif  // USE_SENSOR_MOVE
 namespace motor_handler {
 
 using namespace motor_messages;
@@ -371,17 +376,27 @@ class MotorInterruptHandler {
          */
         return tick_count < buffered_move.duration;
     }
-#ifdef USE_PRESSURE_MOVE
-    auto send_bind_message(can::ids::SensorId sensor, uint8_t binding) -> void {
+#ifdef USE_SENSOR_MOVE
+    auto send_bind_message(can::ids::SensorType sensor_type,
+                           can::ids::SensorId sensor_id, uint8_t binding)
+        -> void {
         auto msg = can::messages::BindSensorOutputRequest{
             .message_index = buffered_move.message_index,
-            .sensor = can::ids::SensorType::pressure,
-            .sensor_id = sensor,
+            .sensor = sensor_type,
+            .sensor_id = sensor_id,
             .binding = binding};
-        if (sensor == can::ids::SensorId::S0) {
-            send_to_pressure_sensor_queue_rear(msg);
-        } else {
-            send_to_pressure_sensor_queue_front(msg);
+        if (sensor_type == can::ids::SensorType::pressure) {
+            if (sensor_id == can::ids::SensorId::S0) {
+                send_to_pressure_sensor_queue_rear(msg);
+            } else {
+                send_to_pressure_sensor_queue_front(msg);
+            }
+        } else if (sensor_type == can::ids::SensorType::capacitive) {
+            if (sensor_id == can::ids::SensorId::S0) {
+                send_to_capacitive_sensor_queue_rear(msg);
+            } else {
+                send_to_capacitive_sensor_queue_front(msg);
+            }
         }
     }
 #endif
@@ -391,14 +406,17 @@ class MotorInterruptHandler {
             hardware.enable_encoder();
             buffered_move.start_encoder_position =
                 hardware.get_encoder_pulses();
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
             if (buffered_move.sensor_id != can::ids::SensorId::UNUSED) {
                 auto binding = static_cast<uint8_t>(0x3);  // sync and report
                 if (buffered_move.sensor_id == can::ids::SensorId::BOTH) {
-                    send_bind_message(can::ids::SensorId::S0, binding);
-                    send_bind_message(can::ids::SensorId::S1, binding);
+                    send_bind_message(buffered_move.sensor_type,
+                                      can::ids::SensorId::S0, binding);
+                    send_bind_message(buffered_move.sensor_type,
+                                      can::ids::SensorId::S1, binding);
                 } else {
-                    send_bind_message(buffered_move.sensor_id, binding);
+                    send_bind_message(buffered_move.sensor_type,
+                                      buffered_move.sensor_id, binding);
                 }
             }
 #endif
@@ -484,15 +502,18 @@ class MotorInterruptHandler {
         tick_count = 0x0;
         stall_handled = false;
         build_and_send_ack(ack_msg_id);
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
         if (buffered_move.sensor_id != can::ids::SensorId::UNUSED) {
-            auto binding =
-                static_cast<uint8_t>(can::ids::SensorOutputBinding::sync);
+            auto binding = static_cast<uint8_t>(
+                can::ids::SensorOutputBinding::sync);  // make none?!
             if (buffered_move.sensor_id == can::ids::SensorId::BOTH) {
-                send_bind_message(can::ids::SensorId::S0, binding);
-                send_bind_message(can::ids::SensorId::S1, binding);
+                send_bind_message(buffered_move.sensor_type,
+                                  can::ids::SensorId::S0, binding);
+                send_bind_message(buffered_move.sensor_type,
+                                  can::ids::SensorId::S1, binding);
             } else {
-                send_bind_message(buffered_move.sensor_id, binding);
+                send_bind_message(buffered_move.sensor_type,
+                                  buffered_move.sensor_id, binding);
             }
         }
 #endif
@@ -638,18 +659,26 @@ class MotorInterruptHandler {
         hardware.set_step_tracker(
             static_cast<uint32_t>(position_tracker >> 31));
     }
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
     void send_to_pressure_sensor_queue_rear(
         can::messages::BindSensorOutputRequest& m) {
-        std::ignore = sensor_tasks::get_queues()
-                          .pressure_sensor_queue_rear->try_write_isr(m);
+        sensor_tasks::get_queues().send_pressure_sensor_queue_rear_isr(m);
     }
     void send_to_pressure_sensor_queue_front(
         can::messages::BindSensorOutputRequest& m) {
         // send to both queues, they will handle their own gating based on
         // sensor id
-        std::ignore = sensor_tasks::get_queues()
-                          .pressure_sensor_queue_front->try_write_isr(m);
+        sensor_tasks::get_queues().send_pressure_sensor_queue_front_isr(m);
+    }
+    void send_to_capacitive_sensor_queue_rear(
+        can::messages::BindSensorOutputRequest& m) {
+        sensor_tasks::get_queues().send_capacitive_sensor_queue_rear_isr(m);
+    }
+    void send_to_capacitive_sensor_queue_front(
+        can::messages::BindSensorOutputRequest& m) {
+        // send to both queues, they will handle their own gating based on
+        // sensor id
+        sensor_tasks::get_queues().send_pressure_sensor_queue_front_isr(m);
     }
 #endif
     uint64_t tick_count = 0x0;
diff --git a/include/motor-control/core/tasks/messages.hpp b/include/motor-control/core/tasks/messages.hpp
index 1f273da04..759a28308 100644
--- a/include/motor-control/core/tasks/messages.hpp
+++ b/include/motor-control/core/tasks/messages.hpp
@@ -6,7 +6,7 @@
 
 namespace motor_control_task_messages {
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 using MotionControlTaskMessage = std::variant<
     std::monostate, can::messages::AddLinearMoveRequest,
     can::messages::DisableMotorRequest, can::messages::EnableMotorRequest,
diff --git a/include/motor-control/core/tasks/motion_controller_task.hpp b/include/motor-control/core/tasks/motion_controller_task.hpp
index 2e8e1d0dc..f8838703b 100644
--- a/include/motor-control/core/tasks/motion_controller_task.hpp
+++ b/include/motor-control/core/tasks/motion_controller_task.hpp
@@ -95,7 +95,7 @@ class MotionControllerMessageHandler {
         controller.move(m);
     }
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
     void handle(const can::messages::AddSensorMoveRequest& m) {
         LOG("Received add linear move request: velocity=%d, acceleration=%d, "
             "groupid=%d, seqid=%d, duration=%d, stopcondition=%d",
diff --git a/include/motor-control/core/tasks/move_group_task.hpp b/include/motor-control/core/tasks/move_group_task.hpp
index 828c370b2..7930d2f25 100644
--- a/include/motor-control/core/tasks/move_group_task.hpp
+++ b/include/motor-control/core/tasks/move_group_task.hpp
@@ -14,7 +14,7 @@ namespace move_group_task {
 
 constexpr std::size_t max_groups = 3;
 constexpr std::size_t max_moves_per_group = 12;
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 using MoveGroupType = move_group::MoveGroupManager<
     max_groups, max_moves_per_group, can::messages::AddLinearMoveRequest,
     can::messages::HomeRequest, can::messages::AddSensorMoveRequest>;
@@ -126,7 +126,7 @@ class MoveGroupMessageHandler {
         mc_client.send_motion_controller_queue(m);
     }
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
     void visit_move(const can::messages::AddSensorMoveRequest& m) {
         mc_client.send_motion_controller_queue(m);
     }
diff --git a/include/pipettes/core/dispatch_builder.hpp b/include/pipettes/core/dispatch_builder.hpp
index 225ef6f1e..e5d0950c6 100644
--- a/include/pipettes/core/dispatch_builder.hpp
+++ b/include/pipettes/core/dispatch_builder.hpp
@@ -39,7 +39,7 @@ using GearMotorDispatchTarget = can::dispatch::DispatchParseTarget<
     can::messages::GearWriteMotorDriverRegister,
     can::messages::GearWriteMotorCurrentRequest>;
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 using MoveGroupDispatchTarget = can::dispatch::DispatchParseTarget<
     can::message_handlers::move_group::MoveGroupHandler<
         linear_motor_tasks::QueueClient>,
@@ -92,7 +92,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/interfaces.hpp b/include/pipettes/core/interfaces.hpp
index 1912d942e..999e5f7ea 100644
--- a/include/pipettes/core/interfaces.hpp
+++ b/include/pipettes/core/interfaces.hpp
@@ -6,7 +6,7 @@
 #include "motor-control/core/tasks/motor_hardware_task.hpp"
 
 namespace interfaces {
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 using MoveQueue = freertos_message_queue::FreeRTOSMessageQueue<
     motor_messages::SensorSyncMove>;
 #else
diff --git a/include/pipettes/core/motor_interrupt_handler.hpp b/include/pipettes/core/motor_interrupt_handler.hpp
deleted file mode 100644
index 94e54ef07..000000000
--- a/include/pipettes/core/motor_interrupt_handler.hpp
+++ /dev/null
@@ -1,48 +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,
-          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,
-          MotorMoveMessage, MotorHardware> {
-  public:
-    using MoveQueue = QueueImpl<MotorMoveMessage>;
-    using UpdatePositionQueue =
-        QueueImpl<can::messages::UpdateMotorPositionEstimationRequest>;
-    PipetteMotorInterruptHandler() = delete;
-    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) {}
-
-    ~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/core/sensor_tasks.hpp b/include/pipettes/core/sensor_tasks.hpp
index 510d82791..0a4f575b3 100644
--- a/include/pipettes/core/sensor_tasks.hpp
+++ b/include/pipettes/core/sensor_tasks.hpp
@@ -98,10 +98,22 @@ struct QueueClient : can::message_writer::MessageWriter {
     void send_capacitive_sensor_queue_front(
         const sensors::utils::TaskMessage& m);
 
+    void send_capacitive_sensor_queue_rear_isr(
+        const sensors::utils::TaskMessage& m);
+
+    void send_capacitive_sensor_queue_front_isr(
+        const sensors::utils::TaskMessage& m);
+
     void send_pressure_sensor_queue_rear(const sensors::utils::TaskMessage& m);
 
     void send_pressure_sensor_queue_front(const sensors::utils::TaskMessage& m);
 
+    void send_pressure_sensor_queue_rear_isr(
+        const sensors::utils::TaskMessage& m);
+
+    void send_pressure_sensor_queue_front_isr(
+        const sensors::utils::TaskMessage& m);
+
     void send_tip_notification_queue_rear(
         const sensors::tip_presence::TaskMessage& m);
 
diff --git a/include/pipettes/firmware/interfaces.hpp b/include/pipettes/firmware/interfaces.hpp
index 8baa83d24..2ff87fcc4 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)
@@ -18,7 +19,7 @@
 
 namespace interfaces {
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 template <typename Client>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client,
diff --git a/include/pipettes/firmware/interfaces_g4.hpp b/include/pipettes/firmware/interfaces_g4.hpp
index 9e4138416..ecf9c0813 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)
@@ -28,25 +28,16 @@
 
 namespace interfaces {
 
-#ifdef USE_PRESSURE_MOVE
+#ifdef USE_SENSOR_MOVE
 template <typename Client>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client,
     motor_messages::SensorSyncMove, motor_hardware::MotorHardware>;
-template <typename Client>
-using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, Client,
-    motor_messages::SensorSyncMove, motor_hardware::MotorHardware,
-    sensor_tasks::QueueClient>;
 #else
 template <typename Client>
 using MotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
     freertos_message_queue::FreeRTOSMessageQueue, Client, motor_messages::Move,
     motor_hardware::MotorHardware>;
-template <typename Client>
-using PipetteMotorInterruptHandlerType = pipettes::PipetteMotorInterruptHandler<
-    freertos_message_queue::FreeRTOSMessageQueue, Client, motor_messages::Move,
-    motor_hardware::MotorHardware, sensor_tasks::QueueClient>;
 #endif
 template <typename Client>
 using GearMotorInterruptHandlerType = motor_handler::MotorInterruptHandler<
@@ -92,14 +83,12 @@ namespace linear_motor {
 
 auto get_interrupt(motor_hardware::MotorHardware& hw,
                    LowThroughputInterruptQueues& queues,
-                   stall_check::StallCheck& stall,
-                   sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
+                   stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
 auto get_interrupt(motor_hardware::MotorHardware& hw,
                    HighThroughputInterruptQueues& queues,
-                   stall_check::StallCheck& stall,
-                   sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
+                   stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
 auto get_motor_hardware(motor_hardware::HardwareConfig pins)
     -> motor_hardware::MotorHardware;
 auto get_motion_control(motor_hardware::MotorHardware& hw,
diff --git a/include/pipettes/simulator/interfaces.hpp b/include/pipettes/simulator/interfaces.hpp
index b646bf55e..418f3417b 100644
--- a/include/pipettes/simulator/interfaces.hpp
+++ b/include/pipettes/simulator/interfaces.hpp
@@ -61,14 +61,27 @@ auto get_interrupt_queues<PipetteType::THREE_EIGHTY_FOUR_CHANNEL>()
 namespace linear_motor {
 
 auto get_interrupt(sim_motor_hardware_iface::SimMotorHardwareIface& hw,
-                   MoveQueue& queue, stall_check::StallCheck& stall,
-                   UpdatePositionQueue& update_queue)
+                   LowThroughputInterruptQueues& queues,
+                   stall_check::StallCheck& stall)
     -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
 
+auto get_interrupt(sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+                   HighThroughputInterruptQueues& queues,
+                   stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient>;
+
+auto get_interrupt_driver(
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    LowThroughputInterruptQueues& queues,
+    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler)
+    -> motor_interrupt_driver::MotorInterruptDriver<
+        linear_motor_tasks::QueueClient, motor_messages::Move,
+        sim_motor_hardware_iface::SimMotorHardwareIface>;
+
 auto get_interrupt_driver(
-    sim_motor_hardware_iface::SimMotorHardwareIface& hw, MoveQueue& queue,
-    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler,
-    UpdatePositionQueue& update_queue)
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    HighThroughputInterruptQueues& queues,
+    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler)
     -> motor_interrupt_driver::MotorInterruptDriver<
         linear_motor_tasks::QueueClient, motor_messages::Move,
         sim_motor_hardware_iface::SimMotorHardwareIface>;
diff --git a/include/sensors/core/message_handlers/sensors.hpp b/include/sensors/core/message_handlers/sensors.hpp
index e888815fe..533db997a 100644
--- a/include/sensors/core/message_handlers/sensors.hpp
+++ b/include/sensors/core/message_handlers/sensors.hpp
@@ -46,9 +46,16 @@ class SensorHandler {
                       can::ids::SensorId(m.sensor_id), m);
     }
 
-    void visit(const can::messages::SendAccumulatedPressureDataRequest &m) {
-        send_to_queue(can::ids::SensorType::pressure,
-                      can::ids::SensorId(m.sensor_id), m);
+    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_driver.hpp b/include/sensors/core/tasks/capacitive_driver.hpp
index 58ab83fbf..ab5963ec5 100644
--- a/include/sensors/core/tasks/capacitive_driver.hpp
+++ b/include/sensors/core/tasks/capacitive_driver.hpp
@@ -23,6 +23,7 @@
 #include "common/core/bit_utils.hpp"
 #include "common/core/logging.h"
 #include "common/core/message_queue.hpp"
+#include "common/core/sensor_buffer.hpp"
 #include "i2c/core/messages.hpp"
 #include "sensors/core/fdc1004.hpp"
 #include "sensors/core/sensor_hardware_interface.hpp"
@@ -40,13 +41,15 @@ class FDC1004 {
   public:
     FDC1004(I2CQueueWriter &writer, I2CQueuePoller &poller,
             CanClient &can_client, OwnQueue &own_queue,
-            sensors::hardware::SensorHardwareBase &hardware, bool shared_sensor)
+            sensors::hardware::SensorHardwareBase &hardware, bool shared_sensor,
+            std::array<float, SENSOR_BUFFER_SIZE> *p_buff)
         : writer(writer),
           poller(poller),
           can_client(can_client),
           own_queue(own_queue),
           hardware(hardware),
-          shared_sensor(shared_sensor) {}
+          shared_sensor(shared_sensor),
+          p_buff(p_buff) {}
 
     [[nodiscard]] auto initialized() const -> bool { return _initialized; }
 
@@ -92,7 +95,12 @@ class FDC1004 {
 
     [[nodiscard]] auto get_offset() const -> float { return current_offset_pf; }
 
-    void set_echoing(bool should_echo) { echoing = should_echo; }
+    void set_echoing(bool should_echo) {
+        echoing = should_echo;
+        if (should_echo) {
+            sensor_buffer_index = 0;  // reset buffer index
+        }
+    }
 
     void set_bind_sync(bool should_bind) {
         bind_sync = should_bind;
@@ -205,6 +213,29 @@ class FDC1004 {
             own_queue, transaction_id);
     }
 
+    void send_accumulated_sensor_data(uint32_t message_index) {
+#ifdef USE_SENSOR_MOVE
+        for (int i = 0; i < sensor_buffer_index; i++) {
+            // send over buffer adn then clear buffer values
+            can_client.send_can_message(
+                can::ids::NodeId::host,
+                can::messages::ReadFromSensorResponse{
+                    .message_index = message_index,
+                    .sensor = can::ids::SensorType::capacitive,
+                    .sensor_id = sensor_id,
+                    .sensor_data =
+                        convert_to_fixed_point((*p_buff).at(i), S15Q16_RADIX)});
+            if (i % 10 == 0) {
+                // slow it down so the can buffer doesn't choke
+                vTaskDelay(50);
+            }
+            (*p_buff).at(i) = 0;
+        }
+#else
+        std::ignore = message_index;
+#endif
+    }
+
     void handle_fdc_response(i2c::messages::TransactionResponse &m) {
         uint16_t reg_int = 0;
         static_cast<void>(bit_utils::bytes_to_int(
@@ -271,6 +302,14 @@ class FDC1004 {
         }
 
         if (echoing) {
+#ifdef USE_SENSOR_MOVE
+            // send a response with 9999 to make an overload of the buffer
+            // visible
+            if (sensor_buffer_index < SENSOR_BUFFER_SIZE) {
+                (*p_buff).at(sensor_buffer_index) = capacitance;
+                sensor_buffer_index++;
+            }
+#else
             can_client.send_can_message(
                 can::ids::NodeId::host,
                 can::messages::ReadFromSensorResponse{
@@ -279,6 +318,7 @@ class FDC1004 {
                     .sensor_id = sensor_id,
                     .sensor_data =
                         convert_to_fixed_point(capacitance, S15Q16_RADIX)});
+#endif
         }
     }
 
@@ -497,6 +537,8 @@ class FDC1004 {
         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
         return RG(*reinterpret_cast<Reg *>(&ret.value()));
     }
+    std::array<float, SENSOR_BUFFER_SIZE> *p_buff;
+    uint16_t sensor_buffer_index = 0;
 
 };  // end of FDC1004 class
 
diff --git a/include/sensors/core/tasks/capacitive_sensor_task.hpp b/include/sensors/core/tasks/capacitive_sensor_task.hpp
index f7416b9d7..15943bdc1 100644
--- a/include/sensors/core/tasks/capacitive_sensor_task.hpp
+++ b/include/sensors/core/tasks/capacitive_sensor_task.hpp
@@ -22,9 +22,10 @@ class CapacitiveMessageHandler {
     explicit CapacitiveMessageHandler(
         I2CQueueWriter &i2c_writer, I2CQueuePoller &i2c_poller,
         sensors::hardware::SensorHardwareBase &hardware, CanClient &can_client,
-        OwnQueue &own_queue, bool shared_task)
-        : driver{i2c_writer, i2c_poller, can_client,
-                 own_queue,  hardware,   shared_task} {}
+        OwnQueue &own_queue, bool shared_task,
+        std::array<float, SENSOR_BUFFER_SIZE> *p_buff)
+        : driver{i2c_writer, i2c_poller,  can_client, own_queue,
+                 hardware,   shared_task, p_buff} {}
     CapacitiveMessageHandler(const CapacitiveMessageHandler &) = delete;
     CapacitiveMessageHandler(const CapacitiveMessageHandler &&) = delete;
     auto operator=(const CapacitiveMessageHandler &)
@@ -65,9 +66,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) {
@@ -211,12 +213,14 @@ class CapacitiveSensorTask {
         i2c::writer::Writer<QueueImpl> *writer,
         i2c::poller::Poller<QueueImpl> *poller,
         sensors::hardware::SensorHardwareBase *hardware, CanClient *can_client,
+        std::array<float, SENSOR_BUFFER_SIZE> *p_buff,
         bool shared_task = false) {
         // On the 8 channel, there is a singular cap sensor but we're using
         // multiple channels. We will thus rely on the sensor id in this case
         // to determine which CIN configuration the sensor should be in.
         auto handler = CapacitiveMessageHandler{
-            *writer, *poller, *hardware, *can_client, get_queue(), shared_task};
+            *writer,     *poller,     *hardware, *can_client,
+            get_queue(), shared_task, p_buff};
         handler.initialize();
         utils::TaskMessage message{};
         for (;;) {
diff --git a/include/sensors/core/tasks/environmental_sensor_task.hpp b/include/sensors/core/tasks/environmental_sensor_task.hpp
index ec641fbe6..e1694a80b 100644
--- a/include/sensors/core/tasks/environmental_sensor_task.hpp
+++ b/include/sensors/core/tasks/environmental_sensor_task.hpp
@@ -75,8 +75,9 @@ 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 f0872519b..d77f2651f 100644
--- a/include/sensors/core/tasks/pressure_driver.hpp
+++ b/include/sensors/core/tasks/pressure_driver.hpp
@@ -8,18 +8,13 @@
 #include "common/core/bit_utils.hpp"
 #include "common/core/logging.h"
 #include "common/core/message_queue.hpp"
+#include "common/core/sensor_buffer.hpp"
 #include "i2c/core/messages.hpp"
 #include "sensors/core/mmr920.hpp"
 #include "sensors/core/sensor_hardware_interface.hpp"
 #include "sensors/core/sensors.hpp"
 #include "sensors/core/utils.hpp"
 
-#if defined(USE_PRESSURE_MOVE)
-constexpr size_t PRESSURE_SENSOR_BUFFER_SIZE = P_BUFF_SIZE;
-#else
-constexpr size_t PRESSURE_SENSOR_BUFFER_SIZE = 0;
-#endif
-
 namespace sensors {
 
 namespace tasks {
@@ -43,7 +38,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),
@@ -73,7 +68,7 @@ class MMR920 {
     void set_echoing(bool should_echo) {
         echoing = should_echo;
         if (should_echo) {
-            pressure_buffer_index = 0;  // reset buffer index
+            sensor_buffer_index = 0;  // reset buffer index
         }
     }
 
@@ -284,9 +279,9 @@ class MMR920 {
             mmr920::ADDRESS, reg_id, 3, STOP_DELAY, own_queue, transaction_id);
     }
 
-    void send_accumulated_pressure_data(uint32_t message_index) {
-#ifdef USE_PRESSURE_MOVE
-        for (int i = 0; i < pressure_buffer_index; i++) {
+    void send_accumulated_sensor_data(uint32_t message_index) {
+#ifdef USE_SENSOR_MOVE
+        for (int i = 0; i < sensor_buffer_index; i++) {
             // send over buffer adn then clear buffer values
             can_client.send_can_message(
                 can::ids::NodeId::host,
@@ -365,10 +360,10 @@ class MMR920 {
 
         if (echo_this_time) {
             auto response_pressure = pressure - current_pressure_baseline_pa;
-#ifdef USE_PRESSURE_MOVE
-            if (pressure_buffer_index < PRESSURE_SENSOR_BUFFER_SIZE) {
-                (*p_buff).at(pressure_buffer_index) = response_pressure;
-                pressure_buffer_index++;
+#ifdef USE_SENSOR_MOVE
+            if (sensor_buffer_index < SENSOR_BUFFER_SIZE) {
+                (*p_buff).at(sensor_buffer_index) = response_pressure;
+                sensor_buffer_index++;
             }
 #else
             can_client.send_can_message(
@@ -563,8 +558,8 @@ class MMR920 {
         value &= Reg::value_mask;
         return write(Reg::address, value);
     }
-    std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> *p_buff;
-    uint16_t pressure_buffer_index = 0;
+    std::array<float, SENSOR_BUFFER_SIZE> *p_buff;
+    uint16_t sensor_buffer_index = 0;
 };
 
 }  // namespace tasks
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/motor-control/core/CMakeLists.txt b/motor-control/core/CMakeLists.txt
index 70ce006a8..c8bce9f50 100644
--- a/motor-control/core/CMakeLists.txt
+++ b/motor-control/core/CMakeLists.txt
@@ -1,9 +1,28 @@
-add_library(motor-utils STATIC 
+add_library(motor-utils STATIC
     motor_hardware_interface.cpp
     stall_check.cpp
-    types.cpp    
+    types.cpp
     utils.cpp)
-target_include_directories(motor-utils PUBLIC 
+
+set_target_properties(motor-utils
+    PROPERTIES CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED TRUE)
+
+target_compile_options(motor-utils
+    PUBLIC
+    -Wall
+    -Werror
+    -Wno-missing-field-initializers
+    -Wextra
+    $<$<COMPILE_LANGUAGE:CXX>:-Weffc++>
+    $<$<COMPILE_LANGUAGE:CXX>:-Wreorder>
+    $<$<COMPILE_LANGUAGE:CXX>:-Wsign-promo>
+    $<$<COMPILE_LANGUAGE:CXX>:-Wextra-semi>
+    $<$<COMPILE_LANGUAGE:CXX>:-Wctor-dtor-privacy>
+    $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>
+    )
+
+target_include_directories(motor-utils PUBLIC
     ${CMAKE_CURRENT_LIST_DIR}/../../include)
 
-add_coverage(motor-utils)
\ No newline at end of file
+add_coverage(motor-utils)
diff --git a/motor-control/core/utils.cpp b/motor-control/core/utils.cpp
index 2fba2eea2..50b8214ab 100644
--- a/motor-control/core/utils.cpp
+++ b/motor-control/core/utils.cpp
@@ -40,6 +40,7 @@ uint32_t fixed_point_multiply(sq31_31 a, uint32_t b) {
 }
 
 int32_t fixed_point_multiply(sq31_31 a, int32_t b, radix_offset_0 _) {
+    static_cast<void>(_);
     int64_t result = static_cast<int64_t>(a) * static_cast<int64_t>(b);
     return static_cast<int32_t>(result >> 31);
 }
diff --git a/pipettes/core/CMakeLists.txt b/pipettes/core/CMakeLists.txt
index f95c9d85c..c0654d2ca 100644
--- a/pipettes/core/CMakeLists.txt
+++ b/pipettes/core/CMakeLists.txt
@@ -1,6 +1,6 @@
 function(target_pipettes_core_common TARGET REVISION)
-    if(${USE_PRESSURE_MOVE})
-    target_compile_definitions(${TARGET} PUBLIC USE_PRESSURE_MOVE)
+    if(${USE_SENSOR_MOVE})
+    target_compile_definitions(${TARGET} PUBLIC USE_SENSOR_MOVE)
     endif()
     target_sources(${TARGET} PUBLIC
             ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/configs.cpp
@@ -17,7 +17,7 @@ endfunction()
 function(target_pipettes_core_single TARGET REVISION)
     target_pipettes_core_common(${TARGET} ${REVISION})
     target_compile_definitions(${TARGET} PUBLIC PIPETTE_TYPE_DEFINE=SINGLE_CHANNEL)
-    if(${USE_PRESSURE_MOVE})
+    if(${USE_SENSOR_MOVE})
     target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=2800)
     endif()
     target_sources(${TARGET} PUBLIC
@@ -27,8 +27,8 @@ endfunction()
 function(target_pipettes_core_multi TARGET REVISION)
     target_pipettes_core_common(${TARGET} ${REVISION})
     target_compile_definitions(${TARGET} PUBLIC PIPETTE_TYPE_DEFINE=EIGHT_CHANNEL)
-    if(${USE_PRESSURE_MOVE})
-    target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=1800)
+    if(${USE_SENSOR_MOVE})
+    target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=1700)
     target_compile_definitions(${TARGET} PUBLIC USE_TWO_BUFFERS=true)
     endif()
     target_sources(${TARGET} PUBLIC
@@ -38,8 +38,8 @@ endfunction()
 function(target_pipettes_core_96 TARGET REVISION)
     target_pipettes_core_common(${TARGET} ${REVISION})
     target_compile_definitions(${TARGET} PUBLIC PIPETTE_TYPE_DEFINE=NINETY_SIX_CHANNEL)
-    if(${USE_PRESSURE_MOVE})
-    target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=900)
+    if(${USE_SENSOR_MOVE})
+    target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=800)
     target_compile_definitions(${TARGET} PUBLIC USE_TWO_BUFFERS=true)
     endif()
     target_sources(${TARGET} PUBLIC
@@ -49,7 +49,7 @@ endfunction()
 function(target_pipettes_core_384 TARGET REVISION)
     target_pipettes_core_common(${TARGET} ${REVISION})
     target_compile_definitions(${TARGET} PUBLIC PIPETTE_TYPE_DEFINE=THREE_EIGHTY_FOUR_CHANNEL)
-    if(${USE_PRESSURE_MOVE})
+    if(${USE_SENSOR_MOVE})
     target_compile_definitions(${TARGET} PUBLIC P_BUFF_SIZE=1500)
     target_compile_definitions(${TARGET} PUBLIC USE_TWO_BUFFERS=true)
     endif()
diff --git a/pipettes/core/sensor_tasks.cpp b/pipettes/core/sensor_tasks.cpp
index bb46b4e21..66fd489d6 100644
--- a/pipettes/core/sensor_tasks.cpp
+++ b/pipettes/core/sensor_tasks.cpp
@@ -6,9 +6,9 @@
 
 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;
 #ifdef USE_TWO_BUFFERS
-static std::array<float, PRESSURE_SENSOR_BUFFER_SIZE> p_buff_front;
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff_front;
 #endif
 static auto eeprom_task_builder =
     freertos_task::TaskStarter<512, eeprom::task::EEPromTask>{};
@@ -77,7 +77,7 @@ void sensor_tasks::start_tasks(
     auto& capacitive_sensor_task_rear =
         capacitive_sensor_task_builder_rear.start(
             5, "capacitive sensor s0", i2c3_task_client, i2c3_poller_client,
-            sensor_hardware_primary, queues);
+            sensor_hardware_primary, queues, p_buff);
     auto& tip_notification_task_rear = tip_notification_task_builder_rear.start(
         5, "tip notification sensor s0", queues, sensor_hardware_primary);
 
@@ -155,7 +155,7 @@ void sensor_tasks::start_tasks(
     auto& capacitive_sensor_task_rear =
         capacitive_sensor_task_builder_rear.start(
             5, "capacitive sensor s0", i2c3_task_client, i2c3_poller_client,
-            sensor_hardware_primary, queues, shared_cap_task);
+            sensor_hardware_primary, queues, p_buff, shared_cap_task);
     auto& tip_notification_task_rear = tip_notification_task_builder_rear.start(
         5, "tip notification sensor s0", queues, sensor_hardware_primary);
 
@@ -188,7 +188,12 @@ void sensor_tasks::start_tasks(
         auto& capacitive_sensor_task_front =
             capacitive_sensor_task_builder_front.start(
                 5, "capacitive sensor s1", i2c2_task_client, i2c2_poller_client,
-                sensor_hardware_primary, queues);
+                sensor_hardware_secondary, queues,
+#ifdef USE_TWO_BUFFERS
+                p_buff_front);
+#else
+                p_buff);
+#endif
         tasks.capacitive_sensor_task_front = &capacitive_sensor_task_front;
         queues.capacitive_sensor_queue_front =
             &capacitive_sensor_task_front.get_queue();
@@ -233,6 +238,18 @@ void sensor_tasks::QueueClient::send_capacitive_sensor_queue_front(
     }
 }
 
+void sensor_tasks::QueueClient::send_capacitive_sensor_queue_rear_isr(
+    const sensors::utils::TaskMessage& m) {
+    std::ignore = capacitive_sensor_queue_rear->try_write_isr(m);
+}
+
+void sensor_tasks::QueueClient::send_capacitive_sensor_queue_front_isr(
+    const sensors::utils::TaskMessage& m) {
+    if (capacitive_sensor_queue_front != nullptr) {
+        std::ignore = capacitive_sensor_queue_front->try_write_isr(m);
+    }
+}
+
 void sensor_tasks::QueueClient::send_pressure_sensor_queue_rear(
     const sensors::utils::TaskMessage& m) {
     pressure_sensor_queue_rear->try_write(m);
@@ -250,6 +267,23 @@ void sensor_tasks::QueueClient::send_pressure_sensor_queue_front(
     }
 }
 
+void sensor_tasks::QueueClient::send_pressure_sensor_queue_rear_isr(
+    const sensors::utils::TaskMessage& m) {
+    std::ignore = pressure_sensor_queue_rear->try_write_isr(m);
+}
+
+void sensor_tasks::QueueClient::send_pressure_sensor_queue_front_isr(
+    const sensors::utils::TaskMessage& m) {
+    // The single channel only has 1 pressure sensor which
+    // is generally referred to as the "rear". In this instance,
+    // the front queue should not be dereferenced and
+    // we should double check this by making sure the
+    // front queue is not a nullptr.
+    if (pressure_sensor_queue_front != nullptr) {
+        std::ignore = pressure_sensor_queue_front->try_write_isr(m);
+    }
+}
+
 void sensor_tasks::QueueClient::send_tip_notification_queue_rear(
     const sensors::tip_presence::TaskMessage& m) {
     if (tip_notification_queue_rear != nullptr) {
diff --git a/pipettes/firmware/interfaces.cpp b/pipettes/firmware/interfaces.cpp
index e8d45f4a2..ff40c65ef 100644
--- a/pipettes/firmware/interfaces.cpp
+++ b/pipettes/firmware/interfaces.cpp
@@ -57,22 +57,20 @@ void linear_motor::encoder_interrupt(motor_hardware::MotorHardware& hw,
 
 auto linear_motor::get_interrupt(motor_hardware::MotorHardware& hw,
                                  LowThroughputInterruptQueues& queues,
-                                 stall_check::StallCheck& stall,
-                                 sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
-    return pipettes::PipetteMotorInterruptHandler(
+                                 stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
+    return motor_handler::MotorInterruptHandler(
         queues.plunger_queue, linear_motor_tasks::get_queues(), hw, stall,
-        queues.plunger_update_queue, sensor_client);
+        queues.plunger_update_queue);
 }
 
 auto linear_motor::get_interrupt(motor_hardware::MotorHardware& hw,
                                  HighThroughputInterruptQueues& queues,
-                                 stall_check::StallCheck& stall,
-                                 sensor_tasks::QueueClient& sensor_client)
-    -> PipetteMotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
-    return pipettes::PipetteMotorInterruptHandler(
+                                 stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
+    return motor_handler::MotorInterruptHandler(
         queues.plunger_queue, linear_motor_tasks::get_queues(), hw, stall,
-        queues.plunger_update_queue, sensor_client);
+        queues.plunger_update_queue);
 }
 
 struct motor_hardware::UsageEEpromConfig plunger_usage_config {
diff --git a/pipettes/firmware/main.cpp b/pipettes/firmware/main.cpp
index 84ef3c5a0..9d43d1788 100644
--- a/pipettes/firmware/main.cpp
+++ b/pipettes/firmware/main.cpp
@@ -102,8 +102,7 @@ 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);
 static auto linear_motion_control =
     interfaces::linear_motor::get_motion_control(linear_motor_hardware,
                                                  interrupt_queues);
diff --git a/pipettes/simulator/interfaces.cpp b/pipettes/simulator/interfaces.cpp
index bab0ed521..8d0301c85 100644
--- a/pipettes/simulator/interfaces.cpp
+++ b/pipettes/simulator/interfaces.cpp
@@ -45,18 +45,45 @@ auto interfaces::get_interrupt_queues<PipetteType::THREE_EIGHTY_FOUR_CHANNEL>()
 }
 
 auto linear_motor::get_interrupt(
-    sim_motor_hardware_iface::SimMotorHardwareIface& hw, MoveQueue& queue,
-    stall_check::StallCheck& stall, UpdatePositionQueue& update_queue)
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    LowThroughputInterruptQueues& queues, stall_check::StallCheck& stall)
+    -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
+    return motor_handler::MotorInterruptHandler(
+        queues.plunger_queue, linear_motor_tasks::get_queues(), hw, stall,
+        queues.plunger_update_queue);
+}
+
+auto linear_motor::get_interrupt(
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    HighThroughputInterruptQueues& queues, stall_check::StallCheck& stall)
     -> MotorInterruptHandlerType<linear_motor_tasks::QueueClient> {
     return motor_handler::MotorInterruptHandler(
-        queue, linear_motor_tasks::get_queues(), hw, stall, update_queue);
+        queues.plunger_queue, linear_motor_tasks::get_queues(), hw, stall,
+        queues.plunger_update_queue);
+}
+
+auto linear_motor::get_interrupt_driver(
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    LowThroughputInterruptQueues& queues,
+    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler)
+#ifdef USE_SENSOR_MOVE
+    -> motor_interrupt_driver::MotorInterruptDriver<
+        linear_motor_tasks::QueueClient, motor_messages::SensorSyncMove,
+        sim_motor_hardware_iface::SimMotorHardwareIface> {
+#else
+    -> motor_interrupt_driver::MotorInterruptDriver<
+        linear_motor_tasks::QueueClient, motor_messages::Move,
+        sim_motor_hardware_iface::SimMotorHardwareIface> {
+#endif
+    return motor_interrupt_driver::MotorInterruptDriver(
+        queues.plunger_queue, handler, hw, queues.plunger_update_queue);
 }
 
 auto linear_motor::get_interrupt_driver(
-    sim_motor_hardware_iface::SimMotorHardwareIface& hw, MoveQueue& queue,
-    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler,
-    UpdatePositionQueue& update_queue)
-#ifdef USE_PRESSURE_MOVE
+    sim_motor_hardware_iface::SimMotorHardwareIface& hw,
+    HighThroughputInterruptQueues& queues,
+    MotorInterruptHandlerType<linear_motor_tasks::QueueClient>& handler)
+#ifdef USE_SENSOR_MOVE
     -> motor_interrupt_driver::MotorInterruptDriver<
         linear_motor_tasks::QueueClient, motor_messages::SensorSyncMove,
         sim_motor_hardware_iface::SimMotorHardwareIface> {
@@ -65,8 +92,8 @@ auto linear_motor::get_interrupt_driver(
         linear_motor_tasks::QueueClient, motor_messages::Move,
         sim_motor_hardware_iface::SimMotorHardwareIface> {
 #endif
-    return motor_interrupt_driver::MotorInterruptDriver(queue, handler, hw,
-                                                        update_queue);
+    return motor_interrupt_driver::MotorInterruptDriver(
+        queues.plunger_queue, handler, hw, queues.plunger_update_queue);
 }
 
 auto linear_motor::get_motor_hardware()
diff --git a/pipettes/simulator/main.cpp b/pipettes/simulator/main.cpp
index 37b1f86cc..c3da9d98b 100644
--- a/pipettes/simulator/main.cpp
+++ b/pipettes/simulator/main.cpp
@@ -60,12 +60,10 @@ static auto gear_stall_check = interfaces::gear_motor::GearStallCheck{
 static auto linear_motor_hardware =
     interfaces::linear_motor::get_motor_hardware();
 static auto plunger_interrupt = interfaces::linear_motor::get_interrupt(
-    linear_motor_hardware, interrupt_queues.plunger_queue, linear_stall_check,
-    interrupt_queues.plunger_update_queue);
+    linear_motor_hardware, interrupt_queues, linear_stall_check);
 static auto plunger_interrupt_driver =
     interfaces::linear_motor::get_interrupt_driver(
-        linear_motor_hardware, interrupt_queues.plunger_queue,
-        plunger_interrupt, interrupt_queues.plunger_update_queue);
+        linear_motor_hardware, interrupt_queues, plunger_interrupt);
 static auto linear_motion_control =
     interfaces::linear_motor::get_motion_control(linear_motor_hardware,
                                                  interrupt_queues);
diff --git a/sensors/tests/test_capacitive_sensor.cpp b/sensors/tests/test_capacitive_sensor.cpp
index 97c139c7b..25f220c5e 100644
--- a/sensors/tests/test_capacitive_sensor.cpp
+++ b/sensors/tests/test_capacitive_sensor.cpp
@@ -30,6 +30,8 @@ auto get_message_i2c(Queue& q) -> Message {
 auto sensor_id = can::ids::SensorId::S0;
 constexpr uint8_t sensor_id_int = 0x0;
 
+static std::array<float, SENSOR_BUFFER_SIZE> p_buff;
+
 SCENARIO("read capacitance sensor values without shared CINs") {
     test_mocks::MockSensorHardware mock_hw{};
     test_mocks::MockMessageQueue<i2c::writer::TaskMessage> i2c_queue{};
@@ -53,7 +55,7 @@ SCENARIO("read capacitance sensor values without shared CINs") {
     poller.set_queue(&poller_queue);
 
     auto sensor_not_shared = sensors::tasks::CapacitiveMessageHandler{
-        writer, poller, mock_hw, queue_client, response_queue, false};
+        writer, poller, mock_hw, queue_client, response_queue, false, &p_buff};
     constexpr uint8_t capacitive_id = 0x1;
 
     GIVEN("a initialize sensor request") {
@@ -381,7 +383,7 @@ SCENARIO("read capacitance sensor values supporting shared CINs") {
     poller.set_queue(&poller_queue);
 
     auto sensor_shared = sensors::tasks::CapacitiveMessageHandler{
-        writer, poller, mock_hw, queue_client, response_queue, true};
+        writer, poller, mock_hw, queue_client, response_queue, true, &p_buff};
     constexpr uint8_t capacitive_id = 0x1;
 
     GIVEN("a initialize sensor request") {
@@ -578,8 +580,8 @@ SCENARIO("capacitance driver tests no shared CINs") {
 
     queue_client.set_queue(&can_queue);
     writer.set_queue(&i2c_queue);
-    sensors::tasks::FDC1004 callback_host(writer, poller, queue_client,
-                                          response_queue, mock_hw, false);
+    sensors::tasks::FDC1004 callback_host(
+        writer, poller, queue_client, response_queue, mock_hw, false, &p_buff);
 
     can::message_writer_task::TaskMessage empty_msg{};
 
@@ -769,7 +771,7 @@ SCENARIO("threshold configuration") {
     poller.set_queue(&poller_queue);
 
     auto sensor = sensors::tasks::CapacitiveMessageHandler{
-        writer, poller, mock_hw, queue_client, response_queue, false};
+        writer, poller, mock_hw, queue_client, response_queue, false, &p_buff};
 
     GIVEN("A request to set an autothreshold") {
         int NUM_READS = 10;
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{};