CHANGELOG.md

@@ -20,6 +20,8 @@ list yields a list of all related PRs for each release.
 - MAX3185 Low Level Handler and Device Handler: Simplifications and bugfixes to allow switching
   off without triggering unrequested replies
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
+- Add remaining missing TMP1075 device handlers.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/318
 
 # [v1.15.0] 27.10.2022
 

README.md

@@ -1108,11 +1108,19 @@ cat /proc/tty/driver
 
 ## I2C
 
-Getting information about I2C device
+Getting information about some I2C device
-````
+
+```sh
 ls /sys/class/i2c-dev/i2c-0/device/device/driver
-````
+```
-This shows the memory mapping of /dev/i2c-0
+This shows the memory mapping of `/dev/i2c-0`.
+
+You can use the `i2cdetect` utility to scan for I2C devices.
+For example, to do this for bus 0 (`/dev/i2c-0`), you can use
+
+```sh
+i2cdetect -r -y 0
+```
 
 ## CAN
 

bsp_q7s/OBSWConfig.h.in

@@ -104,6 +104,7 @@
 #define OBSW_PRINT_CORE_HK                          0
 #define OBSW_DEBUG_PDU1                             0
 #define OBSW_DEBUG_PDU2                             0
+#define OBSW_DEBUG_TMP1075                          0
 #define OBSW_DEBUG_GPS                              0
 #define OBSW_DEBUG_ACU                              0
 #define OBSW_DEBUG_SYRLINKS                         0

bsp_q7s/boardconfig/busConf.h

@@ -8,7 +8,8 @@ static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;
 
 static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 
-static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c_eive";
+static constexpr char I2C_PL_EIVE[] = "/dev/i2c_eive";
+static constexpr char I2C_PS_EIVE[] = "/dev/i2c-2";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";

bsp_q7s/core/ObjectFactory.cpp

@@ -123,18 +123,25 @@ void Factory::setStaticFrameworkObjectIds() {
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
 void ObjectFactory::createTmpComponents() {
-  I2cCookie* i2cCookieTmp1075tcs1 =
+  std::array<std::pair<object_id_t, address_t>, 5> tmpDevIds = {{
-      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
-  I2cCookie* i2cCookieTmp1075tcs2 =
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
-      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  std::vector<I2cCookie*> tmpDevCookies;
 
-  /* Temperature sensors */
+  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
-  Tmp1075Handler* tmp1075Handler_1 =
+    tmpDevCookies.push_back(
-      new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1);
+        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
-  (void)tmp1075Handler_1;
+    auto* tmpDevHandler =
-  Tmp1075Handler* tmp1075Handler_2 =
+        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-      new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2);
+    // TODO: Remove this after TCS subsystem was added
-  (void)tmp1075Handler_2;
+    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
+    // we set them to normal mode immediately here.
+    tmpDevHandler->setModeNormal();
+  }
 }
 
 void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
@@ -574,7 +581,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
 void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   auto* syrlinksUartCookie =
       new SerialCookie(objects::SYRLINKS_HK_HANDLER, q7s::UART_SYRLINKS_DEV, uart::SYRLINKS_BAUD,
-                     syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+                       syrlinks::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   syrlinksUartCookie->setParityEven();
 
   auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HK_HANDLER);
@@ -603,7 +610,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
   auto mpsocCookie =
       new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV, uart::PLOC_MPSOC_BAUD,
-                     mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
+                       mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
   auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
   auto* mpsocHandler = new PlocMPSoCHandler(
@@ -620,7 +627,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   gpioComIF->addGpios(supvGpioCookie);
   auto supervisorCookie =
       new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV,
-                     uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
+                       uart::PLOC_SUPV_BAUD, supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
   auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
   auto* supvHandler = new PlocSupervisorHandler(
@@ -896,7 +903,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
   new SpiTestClass(objects::SPI_TEST, gpioComIF);
 #endif
 #if OBSW_ADD_I2C_TEST_CODE == 1
-  new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV);
+  new I2cTestClass(objects::I2C_TEST, q7s::I2C_PL_EIVE);
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
   // auto* reader= new ScexUartReader(objects::SCEX_UART_READER);
@@ -907,7 +914,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   auto* starTrackerCookie =
       new SerialCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, uart::STAR_TRACKER_BAUD,
-                     startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
+                       startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   auto starTracker =
@@ -918,8 +925,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
 }
 
 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
-  I2cCookie* imtqI2cCookie =
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
-      new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
                                      pcdu::Switches::PDU1_CH3_MGT_5V);
   imtqHandler->setPowerSwitcher(pwrSwitcher);
@@ -935,7 +941,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
 }
 
 void ObjectFactory::createBpxBatteryComponent() {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_DEFAULT_DEV);
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
   BpxBatteryHandler* bpxHandler =
       new BpxBatteryHandler(objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie);
   bpxHandler->setStartUpImmediately();

common/config/eive/objects.h

@@ -39,8 +39,12 @@ enum commonObjects : uint32_t {
   GPS_CONTROLLER = 0x44130045,
 
   IMTQ_HANDLER = 0x44140014,
-  TMP1075_HANDLER_1 = 0x44420004,
+  TMP1075_HANDLER_TCS_0 = 0x44420004,
-  TMP1075_HANDLER_2 = 0x44420005,
+  TMP1075_HANDLER_TCS_1 = 0x44420005,
+  TMP1075_HANDLER_PLPCDU_0 = 0x44420006,
+  TMP1075_HANDLER_PLPCDU_1 = 0x44420007,
+  TMP1075_HANDLER_IF_BOARD = 0x44420008,
+  TMP1075_HANDLER_OBC_IF_BOARD = 0x44420009,
   PCDU_HANDLER = 0x442000A1,
   P60DOCK_HANDLER = 0x44250000,
   PDU1_HANDLER = 0x44250001,

dummies/TemperatureSensorsDummy.cpp

@@ -23,8 +23,8 @@ TemperatureSensorsDummy::TemperatureSensorsDummy()
   ObjectManager::instance()->insert(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, this);
   ObjectManager::instance()->insert(objects::RTD_14_IC17_TCS_BOARD, this);
   ObjectManager::instance()->insert(objects::RTD_15_IC18_IMTQ, this);
-  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_1, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_0, this);
-  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_2, this);
+  ObjectManager::instance()->insert(objects::TMP1075_HANDLER_TCS_1, this);
 }
 
 ReturnValue_t TemperatureSensorsDummy::initialize() {

linux/fsfwconfig/devices/addresses.h

@@ -43,11 +43,14 @@ enum logicalAddresses : address_t {
   DUMMY_GPS1 = 131,
 };
 
-enum i2cAddresses : address_t {
+enum I2cAddress : address_t {
   BPX_BATTERY = 0x07,
   IMTQ = 0x10,
-  TMP1075_TCS_1 = 0x48,
+  TMP1075_TCS_0 = 0x48,
-  TMP1075_TCS_2 = 0x49,
+  TMP1075_TCS_1 = 0x49,
+  TMP1075_PLPCDU_0 = 0x4A,
+  TMP1075_PLPCDU_1 = 0x4B,
+  TMP1075_IF_BOARD = 0x4C,
 };
 
 enum spiAddresses : address_t {

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -55,30 +55,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 #endif
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_WRITE);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_READ);
-#endif
-
-#if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_READ);
-#endif
 
 #if OBSW_ADD_SUN_SENSORS == 1
 
@@ -425,33 +401,78 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   return thisSequence->checkSequence();
 }
 
+// I don't think this needs to be in a PST because linux takes care of bus serialization, but
+// keep it like this for now, it works
 ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
 #if OBSW_ADD_MGT == 1
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 #endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+#endif
+  // These are actually part of another bus, but this works, so keep it like this for now
+#if OBSW_ADD_TMP_DEVICES == 1
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4, DeviceHandlerIF::GET_READ);
 #endif
   static_cast<void>(length);
   return thisSequence->checkSequence();

mission/controller/ThermalController.cpp

@@ -38,8 +38,8 @@ ThermalController::ThermalController(object_id_t objectId)
                     EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
       max31865Set14(objects::RTD_14_IC17_TCS_BOARD, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
       max31865Set15(objects::RTD_15_IC18_IMTQ, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
-      tmp1075Set1(objects::TMP1075_HANDLER_1),
+      tmp1075Set1(objects::TMP1075_HANDLER_TCS_0),
-      tmp1075Set2(objects::TMP1075_HANDLER_2),
+      tmp1075Set2(objects::TMP1075_HANDLER_TCS_1),
       susSet0(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
       susSet1(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
       susSet2(objects::SUS_2_N_LOC_XFYBZB_PT_YB),

mission/devices/Tmp1075Handler.cpp

@@ -86,7 +86,7 @@ ReturnValue_t Tmp1075Handler::interpretDeviceReply(DeviceCommandId_t id, const u
       int16_t tempValueRaw = 0;
       tempValueRaw = packet[0] << 4 | packet[1] >> 4;
       float tempValue = ((static_cast<float>(tempValueRaw)) * 0.0625);
-#if OBSW_VERBOSE_LEVEL >= 1
+#if OBSW_DEBUG_TMP1075 == 1
       sif::info << "Tmp1075 with object id: 0x" << std::hex << getObjectId()
                 << ": Temperature: " << tempValue << " °C" << std::endl;
 #endif
@@ -127,3 +127,5 @@ ReturnValue_t Tmp1075Handler::initializeLocalDataPool(localpool::DataPool &local
       subdp::RegularHkPeriodicParams(dataset.getSid(), false, 30.0));
   return returnvalue::OK;
 }
+
+void Tmp1075Handler::setModeNormal() { setMode(_MODE_TO_NORMAL); }

mission/devices/Tmp1075Handler.h

@@ -20,6 +20,8 @@ class Tmp1075Handler : public DeviceHandlerBase {
   Tmp1075Handler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie);
   virtual ~Tmp1075Handler();
 
+  void setModeNormal();
+
  protected:
   void doStartUp() override;
   void doShutDown() override;