add a getter for max sensor reading

include/bootloader/core/ids.h

@@ -101,6 +101,8 @@ typedef enum {
     can_messageid_gear_set_current_request = 0x505,
     can_messageid_gear_write_motor_driver_request = 0x506,
     can_messageid_gear_read_motor_driver_request = 0x507,
+    can_messageid_max_sensor_value_request = 0x70,
+    can_messageid_max_sensor_value_response = 0x71,
     can_messageid_read_sensor_request = 0x82,
     can_messageid_write_sensor_request = 0x83,
     can_messageid_baseline_sensor_request = 0x84,

include/can/core/ids.hpp

@@ -103,6 +103,8 @@ enum class MessageId {
     gear_set_current_request = 0x505,
     gear_write_motor_driver_request = 0x506,
     gear_read_motor_driver_request = 0x507,
+    max_sensor_value_request = 0x70,
+    max_sensor_value_response = 0x71,
     read_sensor_request = 0x82,
     write_sensor_request = 0x83,
     baseline_sensor_request = 0x84,

include/can/core/messages.hpp

@@ -776,6 +776,53 @@ struct SendAccumulatedSensorDataRequest
         -> bool = default;
 };
 
+struct MaxSensorValueRequest : BaseMessage<MessageId::max_sensor_value_request> {
+    uint32_t message_index = 0;
+    uint8_t sensor = 0;
+    uint8_t sensor_id = 0;
+    uint8_t offset_reading = 0;
+
+    template <bit_utils::ByteIterator Input, typename Limit>
+    static auto parse(Input body, Limit limit) -> MaxSensorValueRequest {
+        uint8_t sensor = 0;
+        uint8_t sensor_id = 0;
+        uint8_t offset_reading = 0;
+        uint32_t msg_ind = 0;
+
+        body = bit_utils::bytes_to_int(body, limit, msg_ind);
+        body = bit_utils::bytes_to_int(body, limit, sensor);
+        body = bit_utils::bytes_to_int(body, limit, sensor_id);
+        body = bit_utils::bytes_to_int(body, limit, offset_reading);
+        return MaxSensorValueRequest{.message_index = msg_ind,
+                                     .sensor = sensor,
+                                     .sensor_id = sensor_id,
+                                     .offset_reading = offset_reading};
+    }
+
+    auto operator==(const MaxSensorValueRequest& other) const -> bool = default;
+};
+
+struct MaxSensorValueResponse
+    : BaseMessage<MessageId::max_sensor_value_response> {
+    uint32_t message_index = 0;
+    can::ids::SensorType sensor{};
+    can::ids::SensorId sensor_id{};
+    int32_t sensor_data = 0;
+
+    template <bit_utils::ByteIterator Output, typename Limit>
+    auto serialize(Output body, Limit limit) const -> uint8_t {
+        auto iter = bit_utils::int_to_bytes(message_index, body, limit);
+        iter =
+            bit_utils::int_to_bytes(static_cast<uint8_t>(sensor), iter, limit);
+        iter = bit_utils::int_to_bytes(static_cast<uint8_t>(sensor_id), iter,
+                                       limit);
+        iter = bit_utils::int_to_bytes(sensor_data, iter, limit);
+        return iter - body;
+    }
+    auto operator==(const MaxSensorValueResponse& other) const
+        -> bool = default;
+};
+
 struct ReadFromSensorRequest : BaseMessage<MessageId::read_sensor_request> {
     uint32_t message_index = 0;
     uint8_t sensor = 0;

include/gripper/core/can_task.hpp

@@ -79,7 +79,8 @@ using SensorDispatchTarget = can::dispatch::DispatchParseTarget<
     can::messages::WriteToSensorRequest, can::messages::BaselineSensorRequest,
     can::messages::SetSensorThresholdRequest,
     can::messages::BindSensorOutputRequest,
-    can::messages::PeripheralStatusRequest>;
+    can::messages::PeripheralStatusRequest,
+    can::messages::MaxSensorValueRequest>;
 
 auto constexpr reader_message_buffer_size = 1024;
 

include/pipettes/core/dispatch_builder.hpp

@@ -96,7 +96,8 @@ using SensorDispatchTarget = can::dispatch::DispatchParseTarget<
     can::messages::WriteToSensorRequest, can::messages::BaselineSensorRequest,
     can::messages::SetSensorThresholdRequest,
     can::messages::BindSensorOutputRequest,
-    can::messages::PeripheralStatusRequest>;
+    can::messages::PeripheralStatusRequest,
+    can::messages::MaxSensorValueRequest>;
 
 using PipetteInfoDispatchTarget = can::dispatch::DispatchParseTarget<
     pipette_info::PipetteInfoMessageHandler<central_tasks::QueueClient,

include/sensors/core/message_handlers/sensors.hpp

@@ -46,6 +46,11 @@ class SensorHandler {
                       can::ids::SensorId(m.sensor_id), m);
     }
 
+    void visit(const can::messages::MaxSensorValueRequest &m) {
+        send_to_queue(can::ids::SensorType(m.sensor),
+                      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) {

include/sensors/core/pie4ioe5.hpp

@@ -30,7 +30,7 @@ enum class registers : uint8_t {
 enum class version_responses : uint8_t {
     // right now only version D1.1 of the pipette sensor board responds
     // version 0 does not respond
-    VERSION_1 = 0x01, // Pipette_sensor board D1.1
+    VERSION_1 = 0x01,  // Pipette_sensor board D1.1
 };
 
 }  // namespace pie4ioe4

include/sensors/core/tasks/capacitive_sensor_task.hpp

@@ -99,6 +99,10 @@ class CapacitiveMessageHandler {
         }
     }
 
+    void visit(const can::messages::MaxSensorValueRequest &m) {
+        std::ignore = m;
+    }
+
     void visit(can::messages::WriteToSensorRequest &m) {
         LOG("Received request to write data %d to %d sensor", m.data, m.sensor);
         // FIXME we should send a response message after a write request

include/sensors/core/tasks/environmental_sensor_task.hpp

@@ -81,6 +81,10 @@ class EnvironmentSensorMessageHandler {
         std::ignore = m;
     }
 
+    void visit(const can::messages::MaxSensorValueRequest &m) {
+        std::ignore = m;
+    }
+
     void visit(const can::messages::BindSensorOutputRequest &m) {
         LOG("Received bind sensor output request from %d sensor", m.sensor);
         // sync doesn't quite mean the same thing here for us. We should

include/sensors/core/tasks/pressure_driver.hpp

@@ -576,6 +576,17 @@ class MMR920 {
 
     auto get_can_client() -> CanClient & { return can_client; }
 
+    auto sensor_version() -> sensors::mmr920::SensorVersion {
+        utils::SensorBoardRev rev = hardware.get_board_rev();
+        switch (rev) {
+            case utils::SensorBoardRev::VERSION_1:
+                return sensors::mmr920::SensorVersion::mmr920c10;
+            case utils::SensorBoardRev::VERSION_0:
+            default:
+                return sensors::mmr920::SensorVersion::mmr920c04;
+        }
+    }
+
   private:
     I2CQueueWriter &writer;
     I2CQueuePoller &poller;
@@ -646,17 +657,6 @@ class MMR920 {
     std::array<float, SENSOR_BUFFER_SIZE> *sensor_buffer;
     uint16_t sensor_buffer_index = 0;
     bool crossed_buffer_index = false;
-
-    auto sensor_version() -> sensors::mmr920::SensorVersion {
-        utils::SensorBoardRev rev = hardware.get_board_rev();
-        switch (rev) {
-            case utils::SensorBoardRev::VERSION_1:
-                return sensors::mmr920::SensorVersion::mmr920c10;
-            case utils::SensorBoardRev::VERSION_0:
-            default:
-                return sensors::mmr920::SensorVersion::mmr920c04;
-        }
-    }
 };
 
 }  // namespace tasks

include/sensors/core/tasks/pressure_sensor_task.hpp

@@ -25,7 +25,8 @@ class PressureMessageHandler {
         const can::ids::SensorId &id,
         std::array<float, SENSOR_BUFFER_SIZE> *sensor_buffer)
         : driver{i2c_writer, i2c_poller, can_client,   own_queue,
-                 hardware,   id,         sensor_buffer} {}
+                 hardware,   id,         sensor_buffer},
+          sensor_id{id} {}
     PressureMessageHandler(const PressureMessageHandler &) = delete;
     PressureMessageHandler(const PressureMessageHandler &&) = delete;
     auto operator=(const PressureMessageHandler &)
@@ -97,6 +98,17 @@ class PressureMessageHandler {
         }
     }
 
+    void visit(const can::messages::MaxSensorValueRequest &m) {
+        auto max = mmr920::get_max_pressure_reading(driver.sensor_version());
+        auto message = can::messages::ReadFromSensorResponse{
+            .message_index = m.message_index,
+            .sensor = SensorType::pressure,
+            .sensor_id = sensor_id,
+            .sensor_data = mmr920::reading_to_fixed_point(max)};
+        driver.get_can_client().send_can_message(can::ids::NodeId::host,
+                                                 message);
+    }
+
     void visit(const can::messages::WriteToSensorRequest &m) {
         LOG("Received request to write data %d to %d sensor\n", m.data,
             m.sensor);
@@ -181,6 +193,7 @@ class PressureMessageHandler {
     }
 
     MMR920<I2CQueueWriter, I2CQueuePoller, CanClient, OwnQueue> driver;
+    can::ids::SensorId sensor_id;
 };
 
 /**

include/sensors/core/utils.hpp

@@ -25,7 +25,8 @@ using CanMessageTuple =
                can::messages::BaselineSensorRequest,
                can::messages::SetSensorThresholdRequest,
                can::messages::BindSensorOutputRequest,
-               can::messages::PeripheralStatusRequest>;
+               can::messages::PeripheralStatusRequest,
+               can::messages::MaxSensorValueRequest>;
 using OtherTaskMessagesTuple = std::tuple<i2c::messages::TransactionResponse>;
 using CanMessageHandler = typename ::utils::TuplesToVariants<
     std::tuple<std::monostate, can::messages::TipStatusQueryRequest>,