Merge branch 'tcs-heater-upper-limit' into tcs-observability

CHANGELOG.md

@@ -24,6 +24,8 @@ will consitute of a breaking change warranting a new major release:
   runtime now. This makes it possible to check the firmware version earlier.
 - The TCS controller will now always command heaters OFF when being blind for thermal
   components (no sensors available), irrespective of current switch state.
+- Make OBSW compatible to prospective FW version v5.0.0, where the Q7 I2C devices were
+  moved to a PL I2C block and the TMP sensor devices were moved to the PS I2C0.
 
 ## Fixed
 

bsp_q7s/boardconfig/busConf.h

@@ -12,6 +12,9 @@ static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
 //! I2C bus using the I2C peripheral of the ARM processing system (PS)
 static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";
+//! I2C bus using the first I2C peripheral of the ARM processing system (PS).
+//! Named like this because it is used by default for the Q7 devices.
+static constexpr char I2C_Q7_EIVE[] = "/dev/i2c_q7";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";

bsp_q7s/em/emObjectFactory.cpp

@@ -68,11 +68,7 @@ void ObjectFactory::produce(void* args) {
       {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
       {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
   }};
-  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  createTmpComponents(tmpDevsToAdd);
-  if (core::FW_VERSION_MAJOR >= 4) {
-    tmpI2cDev = q7s::I2C_PL_EIVE;
-  }
-  createTmpComponents(tmpDevsToAdd, tmpI2cDev);
   dummy::Tmp1075Cfg tmpCfg{};
   tmpCfg.addTcsBrd0 = true;
   tmpCfg.addTcsBrd1 = true;

bsp_q7s/fmObjectFactory.cpp

@@ -77,11 +77,8 @@ void ObjectFactory::produce(void* args) {
       // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
       {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
   }};
-  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+
-  if (core::FW_VERSION_MAJOR >= 4) {
+  createTmpComponents(tmpDevsToAdd);
-    tmpI2cDev = q7s::I2C_PL_EIVE;
-  }
-  createTmpComponents(tmpDevsToAdd, tmpI2cDev);
 #endif
   createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
   createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);

bsp_q7s/objectFactory.cpp

@@ -161,13 +161,19 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
-void ObjectFactory::createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd,
+void ObjectFactory::createTmpComponents(
-                                        const char* i2cDev) {
+    std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd) {
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR == 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  } else if (core::FW_VERSION_MAJOR >= 5) {
+    tmpI2cDev = q7s::I2C_Q7_EIVE;
+  }
   std::vector<I2cCookie*> tmpDevCookies;
 
   for (size_t idx = 0; idx < tmpDevsToAdd.size(); idx++) {
     tmpDevCookies.push_back(
-        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, i2cDev));
+        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, tmpI2cDev));
     auto* tmpDevHandler =
         new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
     tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevsToAdd[idx].first));

bsp_q7s/objectFactory.h

@@ -58,8 +58,7 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
                           bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
-void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd,
+void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd);
-                         const char* i2cDev);
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);

dummies/TemperatureSensorInserter.cpp

@@ -15,7 +15,7 @@ TemperatureSensorInserter::TemperatureSensorInserter(
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
 
 ReturnValue_t TemperatureSensorInserter::initialize() {
-  testCase = TestCase::NONE;
+  testCase = TestCase::COLD_CAMERA_STAYS_COLD;
   return returnvalue::OK;
 }
 
@@ -126,6 +126,21 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
         sif::debug << "Setting CAM temperature back to normal" << std::endl;
         max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(0, true);
       }
+      break;
+    }
+    case (TestCase::COLD_PLOC_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-40, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_CAMERA_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-40, true);
+      }
+      break;
     }
   }
   cycles++;

dummies/TemperatureSensorInserter.h

@@ -33,6 +33,8 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
     COLD_STR_CONSECUTIVE = 5,
     COLD_CAMERA = 6,
     COLD_PLOC_CONSECUTIVE = 7,
+    COLD_PLOC_STAYS_COLD = 8,
+    COLD_CAMERA_STAYS_COLD = 9
   };
   int iteration = 0;
   uint32_t cycles = 0;

mission/controller/ThermalController.cpp

@@ -1814,14 +1814,13 @@ void ThermalController::heaterMaxDurationControl(
       heaterStates[i].switchTransition = false;
       heaterStates[i].heaterSwitchControlCycles = 0;
       heaterStates[i].trackHeaterMaxBurnTime = false;
-      heaterHandler.switchHeater(static_cast<heater::Switch>(i), heater::SwitchState::OFF);
       triggerEvent(tcsCtrl::TCS_HEATER_MAX_BURN_TIME_REACHED, static_cast<uint32_t>(i),
                    MAX_HEATER_ON_DURATIONS_MS[i]);
+      heaterSwitchHelper(static_cast<heater::Switch>(i), heater::SwitchState::OFF,
+                         std::nullopt);
       // The heater might still be one for some thermal components, so cross-check
       // those components
       crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(static_cast<heater::Switch>(i));
-    } else if (currentHeaterStates[i] == heater::SwitchState::OFF) {
-      heaterStates[i].heaterOnMaxBurnTime.resetTimer();
     }
   }
 }
@@ -1868,24 +1867,30 @@ void ThermalController::resetThermalStates() {
   }
 }
 
-void ThermalController::heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState targetState,
+void ThermalController::heaterSwitchHelper(heater::Switch switchNr,
-                                           unsigned componentIdx) {
+                                           heater::SwitchState targetState,
+                                           std::optional<unsigned> componentIdx) {
   timeval currentTime;
   Clock::getClockMonotonic(&currentTime);
   if (targetState == heater::SwitchState::ON) {
     heaterHandler.switchHeater(switchNr, targetState);
     heaterStates[switchNr].target = heater::SwitchState::ON;
     heaterStates[switchNr].switchTransition = true;
-    thermalStates[componentIdx].sensorIndex = ctrlCtx.currentSensorIndex;
+    if (componentIdx.has_value()) {
-    thermalStates[componentIdx].heaterSwitch = switchNr;
+      unsigned componentIdxVal = componentIdx.value();
-    thermalStates[componentIdx].heating = true;
+      thermalStates[componentIdxVal].sensorIndex = ctrlCtx.currentSensorIndex;
-    thermalStates[componentIdx].heaterStartTime = currentTime.tv_sec;
+      thermalStates[componentIdxVal].heaterSwitch = switchNr;
+      thermalStates[componentIdxVal].heating = true;
+      thermalStates[componentIdxVal].heaterStartTime = currentTime.tv_sec;
+    }
     triggerEvent(tcsCtrl::TCS_SWITCHING_HEATER_ON, static_cast<uint32_t>(ctrlCtx.thermalComponent),
                  static_cast<uint32_t>(switchNr));
   } else {
     heaterHandler.switchHeater(switchNr, targetState);
-    thermalStates[componentIdx].heating = false;
+    if (componentIdx.has_value()) {
-    thermalStates[componentIdx].heaterEndTime = currentTime.tv_sec;
+      thermalStates[componentIdx.value()].heating = false;
+      thermalStates[componentIdx.value()].heaterEndTime = currentTime.tv_sec;
+    }
     triggerEvent(tcsCtrl::TCS_SWITCHING_HEATER_OFF, static_cast<uint32_t>(ctrlCtx.thermalComponent),
                  static_cast<uint32_t>(switchNr));
   }

mission/controller/ThermalController.h

@@ -24,6 +24,7 @@
 
 #include <atomic>
 #include <list>
+#include <optional>
 
 class ThermalController : public ExtendedControllerBase {
  public:
@@ -288,7 +289,7 @@ class ThermalController : public ExtendedControllerBase {
 
   void heaterSwitchHelperAllOff();
   void heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState state,
-                          unsigned componentIdx);
+                          std::optional<unsigned> componentIdx);
 
   void ctrlAcsBoard();
   void ctrlMgt();