CMakeLists.txt

@@ -434,8 +434,7 @@ endif()
 target_link_libraries(${LIB_EIVE_MISSION}
                       PUBLIC ${LIB_FSFW_NAME} ${LIB_LWGPS_NAME} ${LIB_OS_NAME})
 
-target_link_libraries(${LIB_DUMMIES}
+target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
-                      PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
 
 target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})
 

bsp_hosted/InitMission.cpp

@@ -1,6 +1,7 @@
 #include "InitMission.h"
 
 #include <OBSWConfig.h>
+#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
@@ -9,7 +10,6 @@
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <mission/utility/InitMission.h>
-#include <bsp_hosted/fsfwconfig/pollingsequence/DummyPst.h>
 
 #include <iostream>
 

bsp_hosted/ObjectFactory.cpp

@@ -2,10 +2,10 @@
 
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
+#include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
 #include <mission/utility/TmFunnel.h>
 #include <objects/systemObjectList.h>
-#include <mission/controller/ThermalController.h>
 #include <tmtc/apid.h>
 #include <tmtc/pusIds.h>
 
@@ -26,23 +26,23 @@
 #include <test/testtasks/TestTask.h>
 #endif
 
-#include <dummies/TemperatureSensorsDummy.h>
-#include <dummies/SusDummy.h>
-#include <dummies/BpxDummy.h>
-#include <dummies/RwDummy.h>
-#include <dummies/StarTrackerDummy.h>
-#include <dummies/SyrlinksDummy.h>
-#include <dummies/ImtqDummy.h>
 #include <dummies/AcuDummy.h>
-#include <dummies/PduDummy.h>
+#include <dummies/BpxDummy.h>
-#include <dummies/P60DockDummy.h>
+#include <dummies/ComCookieDummy.h>
+#include <dummies/ComIFDummy.h>
+#include <dummies/CoreControllerDummy.h>
 #include <dummies/GyroAdisDummy.h>
 #include <dummies/GyroL3GD20Dummy.h>
+#include <dummies/ImtqDummy.h>
 #include <dummies/MgmLIS3MDLDummy.h>
+#include <dummies/P60DockDummy.h>
+#include <dummies/PduDummy.h>
 #include <dummies/PlPcduDummy.h>
-#include <dummies/CoreControllerDummy.h>
+#include <dummies/RwDummy.h>
-#include <dummies/ComIFDummy.h>
+#include <dummies/StarTrackerDummy.h>
-#include <dummies/ComCookieDummy.h>
+#include <dummies/SusDummy.h>
+#include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -5,6 +5,7 @@
  * Generated on: 2021-05-17 19:12:49
  */
 #include "translateObjects.h"
+
 #include "systemObjectList.h"
 
 const char *TEST_TASK_STRING = "TEST_TASK";

bsp_hosted/fsfwconfig/pollingsequence/DummyPst.cpp

@@ -44,7 +44,8 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
@@ -80,37 +81,43 @@ ReturnValue_t dummy_pst::pst(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
-	thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);

dummies/AcuDummy.cpp

@@ -1,4 +1,5 @@
 #include "AcuDummy.h"
+
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 
 AcuDummy::AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -10,22 +11,19 @@ void AcuDummy::doStartUp() {}
 
 void AcuDummy::doShutDown() {}
 
-ReturnValue_t AcuDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+ReturnValue_t AcuDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
-  return NOTHING_TO_SEND;
-}
 
 ReturnValue_t AcuDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t AcuDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                         const uint8_t *commandData,
+                                                const uint8_t *commandData, size_t commandDataLen) {
-                                                         size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t AcuDummy::scanForReply(const uint8_t *start, size_t len,
+ReturnValue_t AcuDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                                              DeviceCommandId_t *foundId, size_t *foundLen) {
+                                     size_t *foundLen) {
   return RETURN_OK;
 }
 
@@ -33,8 +31,7 @@ ReturnValue_t AcuDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t
   return RETURN_OK;
 }
 
-void AcuDummy::fillCommandAndReplyMap() {
+void AcuDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t AcuDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/BpxDummy.cpp

@@ -1,4 +1,5 @@
 #include "BpxDummy.h"
+
 #include <mission/devices/devicedefinitions/BpxBatteryDefinitions.h>
 
 BpxDummy::BpxDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -10,22 +11,19 @@ void BpxDummy::doStartUp() {}
 
 void BpxDummy::doShutDown() {}
 
-ReturnValue_t BpxDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+ReturnValue_t BpxDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
-  return NOTHING_TO_SEND;
-}
 
 ReturnValue_t BpxDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t BpxDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                         const uint8_t *commandData,
+                                                const uint8_t *commandData, size_t commandDataLen) {
-                                                         size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t BpxDummy::scanForReply(const uint8_t *start, size_t len,
+ReturnValue_t BpxDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                                              DeviceCommandId_t *foundId, size_t *foundLen) {
+                                     size_t *foundLen) {
   return RETURN_OK;
 }
 
@@ -33,8 +31,7 @@ ReturnValue_t BpxDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t
   return RETURN_OK;
 }
 
-void BpxDummy::fillCommandAndReplyMap() {
+void BpxDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t BpxDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/CMakeLists.txt

@@ -1,5 +1,6 @@
-target_sources(${LIB_DUMMIES} PUBLIC 
+target_sources(
-TemperatureSensorsDummy.cpp 
+  ${LIB_DUMMIES}
+  PUBLIC TemperatureSensorsDummy.cpp
          SusDummy.cpp
          BpxDummy.cpp
          ComIFDummy.cpp
@@ -15,5 +16,4 @@ GyroAdisDummy.cpp
          GyroL3GD20Dummy.cpp
          MgmLIS3MDLDummy.cpp
          PlPcduDummy.cpp
-CoreControllerDummy.cpp
+         CoreControllerDummy.cpp)
-)

dummies/ComIFDummy.h

@@ -11,7 +11,6 @@
  */
 class ComIFDummy : public DeviceCommunicationIF, public SystemObject {
  public:
-
   ComIFDummy(object_id_t objectId);
   virtual ~ComIFDummy();
 

dummies/CoreControllerDummy.cpp

@@ -1,14 +1,13 @@
 #include "CoreControllerDummy.h"
 
-#include <objects/systemObjectList.h>
 #include <bsp_q7s/core/CoreDefinitions.h>
+#include <objects/systemObjectList.h>
 
 #include <cmath>
 #include <cstdlib>
 
 CoreControllerDummy::CoreControllerDummy(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {
+    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {}
-}
 
 ReturnValue_t CoreControllerDummy::initialize() {
   static bool done = false;
@@ -27,9 +26,7 @@ ReturnValue_t CoreControllerDummy::handleCommandMessage(CommandMessage* message)
   return RETURN_FAILED;
 }
 
-void CoreControllerDummy::performControlOperation() {
+void CoreControllerDummy::performControlOperation() { return; }
-  return;
-}
 
 ReturnValue_t CoreControllerDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                            LocalDataPoolManager& poolManager) {

dummies/GyroAdisDummy.cpp

@@ -11,19 +11,22 @@ void GyroAdisDummy::doStartUp() {}
 
 void GyroAdisDummy::doShutDown() {}
 
-ReturnValue_t GyroAdisDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+ReturnValue_t GyroAdisDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 
 ReturnValue_t GyroAdisDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t GyroAdisDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                const uint8_t *commandData, size_t commandDataLen) {
+                                                     const uint8_t *commandData,
+                                                     size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t GyroAdisDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+ReturnValue_t GyroAdisDummy::scanForReply(const uint8_t *start, size_t len,
-                                     size_t *foundLen) {
+                                          DeviceCommandId_t *foundId, size_t *foundLen) {
   return RETURN_OK;
 }
 

dummies/GyroL3GD20Dummy.cpp

@@ -11,19 +11,22 @@ void GyroL3GD20Dummy::doStartUp() {}
 
 void GyroL3GD20Dummy::doShutDown() {}
 
-ReturnValue_t GyroL3GD20Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+ReturnValue_t GyroL3GD20Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 
 ReturnValue_t GyroL3GD20Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t GyroL3GD20Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                const uint8_t *commandData, size_t commandDataLen) {
+                                                       const uint8_t *commandData,
+                                                       size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t GyroL3GD20Dummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+ReturnValue_t GyroL3GD20Dummy::scanForReply(const uint8_t *start, size_t len,
-                                     size_t *foundLen) {
+                                            DeviceCommandId_t *foundId, size_t *foundLen) {
   return RETURN_OK;
 }
 

dummies/ImtqDummy.cpp

@@ -1,4 +1,5 @@
 #include "ImtqDummy.h"
+
 #include <mission/devices/devicedefinitions/IMTQHandlerDefinitions.h>
 
 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -10,9 +11,7 @@ void ImtqDummy::doStartUp() {}
 
 void ImtqDummy::doShutDown() {}
 
-ReturnValue_t ImtqDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+ReturnValue_t ImtqDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
-  return NOTHING_TO_SEND;
-}
 
 ReturnValue_t ImtqDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
@@ -24,8 +23,8 @@ ReturnValue_t ImtqDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand
   return RETURN_OK;
 }
 
-ReturnValue_t ImtqDummy::scanForReply(const uint8_t *start, size_t len,
+ReturnValue_t ImtqDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                                              DeviceCommandId_t *foundId, size_t *foundLen) {
+                                      size_t *foundLen) {
   return RETURN_OK;
 }
 
@@ -33,8 +32,7 @@ ReturnValue_t ImtqDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_
   return RETURN_OK;
 }
 
-void ImtqDummy::fillCommandAndReplyMap() {
+void ImtqDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t ImtqDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/MgmLIS3MDLDummy.cpp

@@ -11,19 +11,22 @@ void MgmLIS3MDLDummy::doStartUp() {}
 
 void MgmLIS3MDLDummy::doShutDown() {}
 
-ReturnValue_t MgmLIS3MDLDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+ReturnValue_t MgmLIS3MDLDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 
 ReturnValue_t MgmLIS3MDLDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t MgmLIS3MDLDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                const uint8_t *commandData, size_t commandDataLen) {
+                                                       const uint8_t *commandData,
+                                                       size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t MgmLIS3MDLDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+ReturnValue_t MgmLIS3MDLDummy::scanForReply(const uint8_t *start, size_t len,
-                                     size_t *foundLen) {
+                                            DeviceCommandId_t *foundId, size_t *foundLen) {
   return RETURN_OK;
 }
 

dummies/P60DockDummy.cpp

@@ -11,19 +11,22 @@ void P60DockDummy::doStartUp() {}
 
 void P60DockDummy::doShutDown() {}
 
-ReturnValue_t P60DockDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+ReturnValue_t P60DockDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 
 ReturnValue_t P60DockDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t P60DockDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                const uint8_t *commandData, size_t commandDataLen) {
+                                                    const uint8_t *commandData,
+                                                    size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t P60DockDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+ReturnValue_t P60DockDummy::scanForReply(const uint8_t *start, size_t len,
-                                     size_t *foundLen) {
+                                         DeviceCommandId_t *foundId, size_t *foundLen) {
   return RETURN_OK;
 }
 

dummies/PlPcduDummy.cpp

@@ -1,4 +1,5 @@
 #include "PlPcduDummy.h"
+
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 
 PlPcduDummy::PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -33,8 +34,7 @@ ReturnValue_t PlPcduDummy::interpretDeviceReply(DeviceCommandId_t id, const uint
   return RETURN_OK;
 }
 
-void PlPcduDummy::fillCommandAndReplyMap() {
+void PlPcduDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t PlPcduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/RwDummy.cpp

@@ -1,4 +1,5 @@
 #include "RwDummy.h"
+
 #include <mission/devices/devicedefinitions/RwDefinitions.h>
 
 RwDummy::RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -10,22 +11,19 @@ void RwDummy::doStartUp() {}
 
 void RwDummy::doShutDown() {}
 
-ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
-  return NOTHING_TO_SEND;
-}
 
 ReturnValue_t RwDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
 
 ReturnValue_t RwDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                         const uint8_t *commandData,
+                                               const uint8_t *commandData, size_t commandDataLen) {
-                                                         size_t commandDataLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t RwDummy::scanForReply(const uint8_t *start, size_t len,
+ReturnValue_t RwDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                                              DeviceCommandId_t *foundId, size_t *foundLen) {
+                                    size_t *foundLen) {
   return RETURN_OK;
 }
 
@@ -33,8 +31,7 @@ ReturnValue_t RwDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t
   return RETURN_OK;
 }
 
-void RwDummy::fillCommandAndReplyMap() {
+void RwDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t RwDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/StarTrackerDummy.cpp

@@ -1,4 +1,5 @@
 #include "StarTrackerDummy.h"
+
 #include <linux/devices/devicedefinitions/StarTrackerDefinitions.h>
 
 StarTrackerDummy::StarTrackerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -33,8 +34,7 @@ ReturnValue_t StarTrackerDummy::interpretDeviceReply(DeviceCommandId_t id, const
   return RETURN_OK;
 }
 
-void StarTrackerDummy::fillCommandAndReplyMap() {
+void StarTrackerDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t StarTrackerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

dummies/SusDummy.cpp

@@ -6,8 +6,7 @@
 #include <cstdlib>
 
 SusDummy::SusDummy()
-    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT),
+    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) {
-      susSet(this) {
   ObjectManager::instance()->insert(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this);
   ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this);
   ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this);
@@ -34,9 +33,7 @@ ReturnValue_t SusDummy::initialize() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) {
+ReturnValue_t SusDummy::handleCommandMessage(CommandMessage* message) { return RETURN_FAILED; }
-  return RETURN_FAILED;
-}
 
 void SusDummy::performControlOperation() {
   iteration++;
@@ -52,10 +49,9 @@ void SusDummy::performControlOperation() {
   susSet.commit();
 }
 
-ReturnValue_t SusDummy::initializeLocalDataPool(
+ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-    localpool::DataPool& localDataPoolMap, LocalDataPoolManager& poolManager) {
+                                                LocalDataPoolManager& poolManager) {
-  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C,
+  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
-                           new PoolEntry<float>({0}, 1, true));
   localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC, new PoolEntry<uint16_t>({0}));
 
   return RETURN_OK;

dummies/SyrlinksDummy.cpp

@@ -1,4 +1,5 @@
 #include "SyrlinksDummy.h"
+
 #include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
 
 SyrlinksDummy::SyrlinksDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -33,8 +34,7 @@ ReturnValue_t SyrlinksDummy::interpretDeviceReply(DeviceCommandId_t id, const ui
   return RETURN_OK;
 }
 
-void SyrlinksDummy::fillCommandAndReplyMap() {
+void SyrlinksDummy::fillCommandAndReplyMap() {}
-}
 
 uint32_t SyrlinksDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 

linux/ObjectFactory.cpp

@@ -8,10 +8,10 @@
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
+#include <mission/controller/ThermalController.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/Max31865PT1000Handler.h>
 #include <mission/devices/SusHandler.h>
-#include <mission/controller/ThermalController.h>
 #include <mission/system/SusAssembly.h>
 #include <mission/system/TcsBoardAssembly.h>
 #include <mission/system/fdir/RtdFdir.h>

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -125,7 +125,7 @@ namespace status_code {
 static const uint16_t RESERVED_2 = 0x5F2;
 static const uint16_t RESERVED_3 = 0x5F3;
 static const uint16_t RESERVED_4 = 0x5F4;
-}
+}  // namespace status_code
 
 /**
  * @brief   Abstract base class for TC space packet of MPSoC.

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -693,7 +693,8 @@ ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
   sif::info << "PlocMPSoCHandler: CamCmdRpt Ack value: 0x" << std::hex
             << static_cast<unsigned int>(ackValue) << std::endl;
 #endif /* OBSW_DEBUG_PLOC_MPSOC == 1 */
-  handleDeviceTM(packet.getPacketData() + sizeof(uint16_t), packet.getPacketDataLength() - 1, mpsoc::TM_CAM_CMD_RPT);
+  handleDeviceTM(packet.getPacketData() + sizeof(uint16_t), packet.getPacketDataLength() - 1,
+                 mpsoc::TM_CAM_CMD_RPT);
   return result;
 }
 

mission/controller/ThermalController.h

@@ -2,11 +2,11 @@
 #define MISSION_CONTROLLER_THERMALCONTROLLER_H_
 
 #include <fsfw/controller/ExtendedControllerBase.h>
+#include <fsfw/timemanager/Countdown.h>
 #include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
 #include <mission/devices/devicedefinitions/Max31865Definitions.h>
 #include <mission/devices/devicedefinitions/SusDefinitions.h>
 #include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
-#include <fsfw/timemanager/Countdown.h>
 
 class ThermalController : public ExtendedControllerBase {
  public:
@@ -28,14 +28,9 @@ class ThermalController : public ExtendedControllerBase {
                                          uint32_t* msToReachTheMode) override;
 
  private:
-
   static const uint32_t DELAY = 500;
 
-  enum class InternalState {
+  enum class InternalState { STARTUP, INITIAL_DELAY, READY };
-  	STARTUP,
-  	INITIAL_DELAY,
-		READY
-  };
 
   InternalState internalState = InternalState::STARTUP;
 

mission/controller/controllerdefinitions/ThermalControllerDefinitions.h

@@ -164,8 +164,7 @@ class SusTemperatures : public StaticLocalDataSet<ENTRIES_SUS_TEMPERATURE_SET> {
  public:
   SusTemperatures(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SUS_TEMPERATURES) {}
 
-  SusTemperatures(object_id_t objectId)
+  SusTemperatures(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SUS_TEMPERATURES)) {}
-      : StaticLocalDataSet(sid_t(objectId, SUS_TEMPERATURES)) {}
 
   lp_var_t<float> sus_0_n_loc_xfyfzm_pt_xf =
       lp_var_t<float>(sid.objectId, PoolIds::SUS_0_N_LOC_XFYFZM_PT_XF, this);

mission/devices/ACUHandler.cpp

@@ -75,7 +75,8 @@ ReturnValue_t ACUHandler::parseHkTableReply(const uint8_t *packet) {
   dataOffset += 4;
 
   for (size_t idx = 0; idx < 3; idx++) {
-    coreHk.temperatures[idx] = static_cast<int16_t>((packet[dataOffset] << 8) | packet[dataOffset + 1]) * 0.1;
+    coreHk.temperatures[idx] =
+        static_cast<int16_t>((packet[dataOffset] << 8) | packet[dataOffset + 1]) * 0.1;
     dataOffset += 4;
   }
 

mission/devices/GomspaceDeviceHandler.cpp

@@ -472,7 +472,8 @@ ReturnValue_t GomspaceDeviceHandler::parsePduHkTable(PDU::PduCoreHk& coreHk, PDU
   dataOffset += 4;
   auxHk.vbat = *(packet + dataOffset) << 8 | *(packet + dataOffset + 1);
   dataOffset += 4;
-  coreHk.temperature = static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
+  coreHk.temperature =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
 
   for (uint8_t idx = 0; idx < 3; idx++) {

mission/devices/HeaterHandler.h

@@ -14,8 +14,8 @@
 #include <fsfw/timemanager/Countdown.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 
-#include <vector>
 #include <array>
+#include <vector>
 
 #include "devices/heaterSwitcherList.h"
 

mission/devices/Max31865EiveHandler.cpp

@@ -181,7 +181,8 @@ ReturnValue_t Max31865EiveHandler::initializeLocalDataPool(localpool::DataPool&
   using namespace MAX31865;
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::RTD_VALUE), new PoolEntry<float>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C), new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::LAST_FAULT_BYTE), new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::LAST_FAULT_BYTE),
+                           new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::FAULT_BYTE), new PoolEntry<uint8_t>({0}));
   poolManager.subscribeForPeriodicPacket(sensorDataset.getSid(), false, 30.0, false);
   return RETURN_OK;

mission/devices/P60DockHandler.cpp

@@ -57,9 +57,11 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
     dataOffset += 3;
   }
 
-  coreHk.temperature1 = static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
+  coreHk.temperature1 =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
-  coreHk.temperature2 = static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
+  coreHk.temperature2 =
+      static_cast<int16_t>(*(packet + dataOffset) << 8 | *(packet + dataOffset + 1)) * 0.1;
   dataOffset += 4;
 
   auxHk.bootcause = *(packet + dataOffset) << 24 |

mission/devices/Tmp1075Handler.cpp

@@ -95,8 +95,7 @@ ReturnValue_t Tmp1075Handler::interpretDeviceReply(DeviceCommandId_t id, const u
         dataset.temperatureCelcius = tempValue;
         dataset.setValidity(true, true);
         dataset.commit();
-      }
+      } else {
-      else {
         dataset.setValidity(false, true);
       }
       break;

mission/utility/compileTime.h

@@ -38,18 +38,37 @@
 
 // Custom "glue logic" to convert the month name to a usable number
 #define GET_MONTH(str, i)                                                                         \
-  (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n'   ? 1  \
+  (str[i] == 'J' && str[i + 1] == 'a' && str[i + 2] == 'n'                                        \
-   : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b' ? 2  \
+       ? 1                                                                                        \
-   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r' ? 3  \
+       : str[i] == 'F' && str[i + 1] == 'e' && str[i + 2] == 'b'                                  \
-   : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r' ? 4  \
+             ? 2                                                                                  \
-   : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y' ? 5  \
+             : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'r'                            \
-   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n' ? 6  \
+                   ? 3                                                                            \
-   : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l' ? 7  \
+                   : str[i] == 'A' && str[i + 1] == 'p' && str[i + 2] == 'r'                      \
-   : str[i] == 'A' && str[i + 1] == 'u' && str[i + 2] == 'g' ? 8  \
+                         ? 4                                                                      \
-   : str[i] == 'S' && str[i + 1] == 'e' && str[i + 2] == 'p' ? 9  \
+                         : str[i] == 'M' && str[i + 1] == 'a' && str[i + 2] == 'y'                \
-   : str[i] == 'O' && str[i + 1] == 'c' && str[i + 2] == 't' ? 10 \
+                               ? 5                                                                \
-   : str[i] == 'N' && str[i + 1] == 'o' && str[i + 2] == 'v' ? 11 \
+                               : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'n'          \
-   : str[i] == 'D' && str[i + 1] == 'e' && str[i + 2] == 'c' ? 12 \
+                                     ? 6                                                          \
+                                     : str[i] == 'J' && str[i + 1] == 'u' && str[i + 2] == 'l'    \
+                                           ? 7                                                    \
+                                           : str[i] == 'A' && str[i + 1] == 'u' &&                \
+                                                     str[i + 2] == 'g'                            \
+                                                 ? 8                                              \
+                                                 : str[i] == 'S' && str[i + 1] == 'e' &&          \
+                                                           str[i + 2] == 'p'                      \
+                                                       ? 9                                        \
+                                                       : str[i] == 'O' && str[i + 1] == 'c' &&    \
+                                                                 str[i + 2] == 't'                \
+                                                             ? 10                                 \
+                                                             : str[i] == 'N' &&                   \
+                                                                       str[i + 1] == 'o' &&       \
+                                                                       str[i + 2] == 'v'          \
+                                                                   ? 11                           \
+                                                                   : str[i] == 'D' &&             \
+                                                                             str[i + 1] == 'e' && \
+                                                                             str[i + 2] == 'c'    \
+                                                                         ? 12                     \
                                                                          : 0)
 
 // extract the information from the time string given by __TIME__ and __DATE__

scripts/auto-formatter.sh

@@ -12,6 +12,7 @@ folder_list=(
   "./bsp_egse"
   "./test"
   "./common"
+  "./dummies"
 )
 
 cmake_fmt="cmake-format"

unittest/controller/testThermalController.cpp

@@ -1,9 +1,9 @@
 #include <dummies/SusDummy.h>
 #include <dummies/TemperatureSensorsDummy.h>
 #include <fsfw/ipc/QueueFactory.h>
-#include <mission/controller/ThermalController.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <mission/controller/ThermalController.h>
 
 #include <catch2/catch_test_macros.hpp>