fix(thermocycler-gen2): handle systick overflow in thermal control tasks (#432)

Author: fsinapi

stm32-modules/include/thermocycler-gen2/thermocycler-gen2/lid_heater_task.hpp

@@ -157,6 +157,8 @@ class LidHeaterTask {
     requires LidHeaterExecutionPolicy<Policy>
     auto visit_message(const messages::LidTempReadComplete& msg, Policy& policy)
         -> void {
+        constexpr Milliseconds time_overflow_amount = Milliseconds(
+            std::numeric_limits<decltype(msg.timestamp_ms)>::max());
         auto old_error_bitmap = _state.error_bitmap;
         auto current_time = Milliseconds(msg.timestamp_ms);
         handle_temperature_conversion(msg.lid_temp, _thermistor);
@@ -174,9 +176,12 @@ class LidHeaterTask {
 
         // If we're in a controlling state, we now update the heater output
         if (_state.system_status == State::CONTROLLING) {
+            auto time_delta = current_time - _last_update;
+            if (time_delta.count() < 0) {
+                time_delta += time_overflow_amount;
+            }
             auto power = update_control(
-                std::chrono::duration_cast<Seconds>(current_time - _last_update)
-                    .count());
+                std::chrono::duration_cast<Seconds>(time_delta).count());
             auto ret = policy.set_heater_power(power);
             if (!ret) {
                 policy.set_heater_power(0.0F);

stm32-modules/include/thermocycler-gen2/thermocycler-gen2/thermal_plate_task.hpp

@@ -278,6 +278,8 @@ class ThermalPlateTask {
     requires ThermalPlateExecutionPolicy<Policy>
     auto visit_message(const messages::ThermalPlateTempReadComplete& msg,
                        Policy& policy) -> void {
+        constexpr Milliseconds time_overflow_amount = Milliseconds(
+            std::numeric_limits<decltype(msg.timestamp_ms)>::max());
         auto old_error_bitmap = _state.error_bitmap;
         auto current_time = Milliseconds(msg.timestamp_ms);
 
@@ -327,8 +329,12 @@ class ThermalPlateTask {
         }
 
         if (_state.system_status == State::CONTROLLING) {
-            update_control(policy, std::chrono::duration_cast<Seconds>(
-                                       current_time - _last_update));
+            auto time_delta = current_time - _last_update;
+            if (time_delta.count() < 0) {
+                time_delta += time_overflow_amount;
+            }
+            update_control(policy,
+                           std::chrono::duration_cast<Seconds>(time_delta));
             send_current_state();
         } else if (_state.system_status == State::IDLE) {
             send_current_state();

stm32-modules/thermocycler-gen2/tests/test_thermal_plate_task.cpp

@@ -1233,4 +1233,61 @@ TEST_CASE("thermal plate error flag handling") {
             }
         }
     }
+}
+
+TEST_CASE("thermal plate tick overflow handling") {
+    constexpr uint32_t max_tick = std::numeric_limits<uint32_t>::max();
+    const uint32_t ms_diff = GENERATE(10, 1000, 10000);
+    constexpr float temperature = 15;
+    constexpr uint32_t total_hold = 5000;
+    GIVEN("a thermal plate task with valid temperatures holding temp") {
+        auto tasks = TaskBuilder::build();
+        auto &plate_queue = tasks->get_thermal_plate_queue();
+        auto &host_queue = tasks->get_host_comms_queue();
+        auto valid_adc = _converter.backconvert(temperature);
+        auto read_message = messages::ThermalPlateTempReadComplete{
+            .heat_sink = valid_adc,
+            .front_right = valid_adc,
+            .front_center = valid_adc,
+            .front_left = valid_adc,
+            .back_right = valid_adc,
+            .back_center = valid_adc,
+            .back_left = valid_adc,
+            .timestamp_ms = max_tick - 100};
+        std::ignore = plate_queue.try_send(read_message);
+        tasks->run_thermal_plate_task();
+        auto command = messages::SetPlateTemperatureMessage{
+            .id = 123,
+            .setpoint = temperature,
+            .hold_time = total_hold,
+            .volume = 1,
+        };
+        std::ignore = plate_queue.try_send(command);
+        tasks->run_thermal_plate_task();
+
+        read_message.timestamp_ms = max_tick - 50;
+        std::ignore = plate_queue.try_send(read_message);
+        tasks->run_thermal_plate_task();
+
+        read_message.timestamp_ms = max_tick - 25;
+        std::ignore = plate_queue.try_send(read_message);
+        tasks->run_thermal_plate_task();
+
+        WHEN("sending a thermistor update that overflows the tick count") {
+            read_message.timestamp_ms += ms_diff;
+            std::ignore = plate_queue.try_send(read_message);
+            tasks->run_thermal_plate_task();
+            THEN("the new hold time makes sense") {
+                auto expected = total_hold - (ms_diff / 1000.0);
+                host_queue.backing_deque.clear();
+                auto get_message = messages::GetPlateTempMessage{.id = 321};
+                std::ignore = plate_queue.try_send(get_message);
+                tasks->run_thermal_plate_task();
+                auto response = std::get<messages::GetPlateTempResponse>(
+                    host_queue.backing_deque.front());
+                REQUIRE_THAT(response.time_remaining,
+                             Catch::Matchers::WithinAbs(expected, 0.01));
+            }
+        }
+    }
 }