update PUS5 TM format

CHANGELOG.md

@@ -26,7 +26,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
-- functions to configure pus routing
 - FreeRTOS monotonic clock which is not subjected to time jumps of the system clock
 - add CFDP subsystem ID
   https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
@@ -36,7 +35,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Changed
 
-- send HK one-parameter-report back to sender instead of default hk queue
 - Complete overhaul of HK subsystem. Replaced local data pool manager by periodic HK
   helper. The shared pool and the periodic HK generation are now distinct concepts.
 - The local HK manager was replaced by a periodic HK helper which has reduced responsibilities.
@@ -70,8 +68,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   configurable.
 - Switched to vendored versions for both the Embedded Template Library (ETL) and the
   Catch2 unittesting library.
-- Increased maximum number of mode tables from 70 to 100
-- Exposed health table mutex via getter function
+
 ## Added
 
 - `EventManager`: Add function to print all listeners.

misc/archive/MgmRM3100Handler.h

@@ -18,13 +18,13 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   static const uint8_t INTERFACE_ID = CLASS_ID::MGM_RM3100;
 
   //! [EXPORT] : [COMMENT] P1: TMRC value which was set, P2: 0
-  static constexpr Event tmrcSet = event::makeEvent<SUBSYSTEM_ID::MGM_RM3100, 0x00, severity::INFO>();
+  static constexpr Event tmrcSet = event::makeEvent(SUBSYSTEM_ID::MGM_RM3100, 0x00, severity::INFO);
 
   //! [EXPORT] : [COMMENT] Cycle counter set. P1: First two bytes new Cycle Count X
   //! P1: Second two bytes new Cycle Count Y
   //! P2: New cycle count Z
   static constexpr Event cycleCountersSet =
-      event::makeEvent<SUBSYSTEM_ID::MGM_RM3100, 0x01, severity::INFO>();
+      event::makeEvent(SUBSYSTEM_ID::MGM_RM3100, 0x01, severity::INFO);
 
   MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                    uint32_t transitionDelay);

misc/defaultcfg/fsfwconfig/FSFWConfig.h

@@ -71,7 +71,6 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
 
 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
-static constexpr size_t FSFW_PRINT_BUFFER_AMOUNT = 32;
 
 static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
 

scripts/auto-formatter.sh

@@ -18,12 +18,12 @@ else
   echo "No ${cmake_fmt} tool found, not formatting CMake files"
 fi
 
-cpp_format="clang-format-19"
+cpp_format="clang-format"
 file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
 if command -v ${cpp_format} &> /dev/null; then
   for dir in ${folder_list[@]}; do
     echo "Auto-formatting ${dir} recursively"
-    find ${dir} ${file_selectors} | xargs ${cpp_format} --style=file -i
+    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
   done
 else
   echo "No ${cpp_format} tool found, not formatting C++/C files"

src/fsfw/cfdp/handler/DestHandler.cpp

@@ -9,9 +9,7 @@
 #include "fsfw/cfdp/pdu/FileDataReader.h"
 #include "fsfw/cfdp/pdu/FinishedPduCreator.h"
 #include "fsfw/cfdp/pdu/HeaderReader.h"
-#include "fsfw/cfdp/pdu/KeepAlivePduCreator.h"
 #include "fsfw/objectmanager.h"
-#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 
 using namespace returnvalue;
@@ -452,19 +450,6 @@ ReturnValue_t cfdp::DestHandler::noticeOfCompletion() {
   return OK;
 }
 
-ReturnValue_t cfdp::DestHandler::sendKeepAlivePdu() {
-  Fss progress(transactionParams.progress);
-  KeepAlivePduCreator keepAlivePdu(transactionParams.pduConf, progress);
-  size_t serLen = 0;
-  ReturnValue_t result =
-      keepAlivePdu.serialize(pduBuf.data(), serLen, keepAlivePdu.getSerializedSize());
-  if (result != OK) {
-    return result;
-  }
-  return pduSender.sendPdu(PduType::FILE_DIRECTIVE, FileDirective::KEEP_ALIVE, pduBuf.data(),
-                           serLen);
-}
-
 ReturnValue_t cfdp::DestHandler::sendFinishedPdu() {
   FinishedInfo info(transactionParams.conditionCode, transactionParams.deliveryCode,
                     transactionParams.deliveryStatus);
@@ -511,8 +496,6 @@ const cfdp::TransactionId& cfdp::DestHandler::getTransactionId() const {
   return transactionParams.transactionId;
 }
 
-uint64_t cfdp::DestHandler::getProgress() const { return transactionParams.progress; }
-
 void cfdp::DestHandler::checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx) {
   if (result != OK and errorIdx < 3) {
     fsmRes.errorCodes[errorIdx] = result;
@@ -526,4 +509,4 @@ void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) {
 
 const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const {
   return destParams;
-}
+}

src/fsfw/cfdp/handler/DestHandler.h

@@ -101,8 +101,6 @@ class DestHandler {
 
   [[nodiscard]] CfdpState getCfdpState() const;
   [[nodiscard]] TransactionStep getTransactionStep() const;
-  [[nodiscard]] uint64_t getProgress() const;
-  ReturnValue_t sendKeepAlivePdu();
   [[nodiscard]] const TransactionId& getTransactionId() const;
   [[nodiscard]] const DestHandlerParams& getDestHandlerParams() const;
 

src/fsfw/cfdp/handler/defs.h

@@ -19,13 +19,13 @@ struct FsfwParams {
 };
 
 namespace events {
-static constexpr Event PDU_SEND_ERROR = event::makeEvent<SSID, 1, severity::LOW>();
-static constexpr Event SERIALIZATION_ERROR = event::makeEvent<SSID, 2, severity::LOW>();
-static constexpr Event FILESTORE_ERROR = event::makeEvent<SSID, 3, severity::LOW>();
+static constexpr Event PDU_SEND_ERROR = event::makeEvent(SSID, 1, severity::LOW);
+static constexpr Event SERIALIZATION_ERROR = event::makeEvent(SSID, 2, severity::LOW);
+static constexpr Event FILESTORE_ERROR = event::makeEvent(SSID, 3, severity::LOW);
 //! [EXPORT] : [COMMENT] P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name
-static constexpr Event FILENAME_TOO_LARGE_ERROR = event::makeEvent<SSID, 4, severity::LOW>();
+static constexpr Event FILENAME_TOO_LARGE_ERROR = event::makeEvent(SSID, 4, severity::LOW);
 //! [EXPORT] : [COMMENT] CFDP request handling failed. P2: Returncode.
-static constexpr Event HANDLING_CFDP_REQUEST_FAILED = event::makeEvent<SSID, 5, severity::LOW>();
+static constexpr Event HANDLING_CFDP_REQUEST_FAILED = event::makeEvent(SSID, 5, severity::LOW);
 }  // namespace events
 
 static constexpr ReturnValue_t SOURCE_TRANSACTION_PENDING = returnvalue::makeCode(CID, 0);

src/fsfw/cfdp/pdu/KeepAlivePduCreator.h

@@ -14,7 +14,6 @@ class KeepAlivePduCreator : public FileDirectiveCreator {
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           Endianness streamEndianness) const override;
-  using FileDirectiveCreator::serialize;
 
  private:
   cfdp::Fss& progress;

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -71,8 +71,7 @@ bool AssemblyBase::handleChildrenChangedHealth() {
   if (iter == childrenMap.end()) {
     return false;
   }
-  HealthState healthState =
-      healthHelper.healthTable->getHealth(convertToDeviceObjectId(iter->first));
+  HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
   if (healthState == HasHealthIF::NEEDS_RECOVERY) {
     triggerEvent(TRYING_RECOVERY, iter->first, 0);
     recoveryState = RECOVERY_STARTED;
@@ -92,14 +91,10 @@ bool AssemblyBase::handleChildrenChangedHealth() {
 void AssemblyBase::handleChildrenTransition() {
   if (commandsOutstanding <= 0) {
     switch (internalState) {
-      case STATE_NEED_SECOND_STEP: {
+      case STATE_NEED_SECOND_STEP:
         internalState = STATE_SECOND_STEP;
-        ReturnValue_t result = commandChildren(targetMode, targetSubmode);
-        if (result == NEED_SECOND_STEP) {
-          internalState = STATE_NEED_SECOND_STEP;
-        }
+        commandChildren(targetMode, targetSubmode);
         return;
-      }
       case STATE_OVERWRITE_HEALTH: {
         internalState = STATE_SINGLE_STEP;
         ReturnValue_t result = commandChildren(mode, submode);
@@ -175,7 +170,7 @@ ReturnValue_t AssemblyBase::checkChildrenStateOff() {
 
 ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
   ChildInfo childInfo = childrenMap.find(objectId)->second;
-  if (healthHelper.healthTable->isCommandable(convertToDeviceObjectId(objectId))) {
+  if (healthHelper.healthTable->isCommandable(objectId)) {
     if (childInfo.submode != SUBMODE_NONE) {
       return returnvalue::FAILED;
     } else {
@@ -232,7 +227,7 @@ bool AssemblyBase::checkAndHandleRecovery() {
     case RECOVERY_STARTED:
       // The recovery was already start in #handleChildrenChangedHealth and we just need
       // to wait for an off time period.
-      // The timeout can be defined by #setRecoveryWaitTimer
+      // TODO: make time period configurable
       recoveryState = RECOVERY_WAIT;
       recoveryOffTimer.resetTimer();
       return true;
@@ -240,14 +235,14 @@ bool AssemblyBase::checkAndHandleRecovery() {
       if (recoveryOffTimer.isBusy()) {
         return true;
       }
-      triggerEvent(RECOVERY_WAITING, recoveringDevice->first);
+      triggerEvent(RECOVERY_STEP, 0);
       sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
       internalState = STATE_NONE;
       recoveryState = RECOVERY_ONGOING;
       // Don't check state!
       return true;
     case RECOVERY_ONGOING:
-      triggerEvent(RECOVERY_RESTARTING, recoveringDevice->first);
+      triggerEvent(RECOVERY_STEP, 1);
       recoveryState = RECOVERY_ONGOING_2;
       recoveringDevice->second.healthChanged = false;
       // Device should be healthy again, so restart a transition.
@@ -255,7 +250,7 @@ bool AssemblyBase::checkAndHandleRecovery() {
       doStartTransition(targetMode, targetSubmode);
       return true;
     case RECOVERY_ONGOING_2:
-      triggerEvent(RECOVERY_DONE, recoveringDevice->first);
+      triggerEvent(RECOVERY_DONE);
       // Now we're through, but not sure if it was successful.
       recoveryState = RECOVERY_IDLE;
       return false;
@@ -269,14 +264,7 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
   triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
   internalState = STATE_OVERWRITE_HEALTH;
   modeHelper.setForced(true);
-  if (childrenMap.find(objectId) != childrenMap.end()) {
-    sendHealthCommand(childrenMap.at(objectId).commandQueue, EXTERNAL_CONTROL);
-  } else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << std::hex << SystemObject::getObjectId() << ": invalid mode table entry"
-               << std::endl;
-#endif
-  }
+  sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }
 
 void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
@@ -286,7 +274,3 @@ void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
     triggerEvent(CHANGING_MODE, mode, submode);
   }
 }
-
-void AssemblyBase::setRecoveryWaitTimer(uint32_t timeoutMS) {
-  recoveryOffTimer.setTimeout(timeoutMS);
-}

src/fsfw/devicehandlers/AssemblyBase.h

@@ -206,8 +206,6 @@ class AssemblyBase : public SubsystemBase {
   void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
 
   void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
-
-  void setRecoveryWaitTimer(uint32_t timeoutMS);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */

src/fsfw/events/Event.h

@@ -5,31 +5,30 @@
 
 #include "fwSubsystemIdRanges.h"
 
-using EventId_t = uint16_t;
 using EventSeverity_t = uint8_t;
-using UniqueEventId_t = uint8_t;
+using GroupId_t = uint16_t;
+using UniqueEventId_t = uint16_t;
 
 namespace severity {
-enum Severity : EventSeverity_t { INFO = 1, LOW = 2, MEDIUM = 3, HIGH = 4 };
+enum Severity : EventSeverity_t { INFO = 0, LOW = 1, MEDIUM = 2, HIGH = 3 };
 
 }  // namespace severity
 
+#define MAKE_EVENT(id, severity) (((severity) << 30) | (SUBSYSTEM_ID << 16) | id)
+
 typedef uint32_t Event;
 
 namespace event {
 
-constexpr EventId_t getEventId(Event event) { return (event & 0xFFFF); }
+constexpr UniqueEventId_t getEventId(Event event) { return (event & 0xFFFF); }
 
-constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 16) & 0xFF); }
+constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 30) & 0b11); }
 
-template <uint8_t subsystemId, UniqueEventId_t uniqueEventId, EventSeverity_t eventSeverity>
-constexpr Event makeEvent() {
-  static_assert(uniqueEventId < 100, "The unique event ID must be smaller than 100!");
-  return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+constexpr Event makeEvent(GroupId_t groupId, UniqueEventId_t uniqueEventId,
+                          EventSeverity_t eventSeverity) {
+  return (eventSeverity << 30) | (groupId << 16) | uniqueEventId;
 }
 
 }  // namespace event
 
-#define MAKE_EVENT(id, severity) event::makeEvent<SUBSYSTEM_ID, id, severity>();
-
 #endif /* EVENTOBJECT_EVENT_H_ */

src/fsfw/health/HasHealthIF.h

@@ -27,19 +27,13 @@ class HasHealthIF {
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
   //! Assembly overwrites health information of children to keep satellite alive.
   static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
-  //! Someone starts a recovery of a component (typically power-cycle).
-  //! P1: Object Id of the recovering device.
+  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
   static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  //! Recovery is ongoing. Comes twice during recovery.
+  //! P1: 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
   //! Recovery was completed. Not necessarily successful. No parameters.
-  //! P1: Object Id of the recovering device.
   static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
-  //! Recovery is ongoing. The recovering device is currently OFF, waiting for restart.
-  //! P1: Object Id of the recovering device.
-  static const Event RECOVERY_WAITING = MAKE_EVENT(13, severity::MEDIUM);
-  //! Recovery is ongoing. Restarting the recovering device.
-  //! P1: Object Id of the recovering device.
-  static const Event RECOVERY_RESTARTING = MAKE_EVENT(14, severity::MEDIUM);
-
   virtual ~HasHealthIF() {}
 
   virtual MessageQueueId_t getCommandQueue() const = 0;

src/fsfw/health/HealthTable.cpp

@@ -17,11 +17,11 @@ void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t tim
 HealthTable::~HealthTable() { MutexFactory::instance()->deleteMutex(mutex); }
 
 ReturnValue_t HealthTable::registerObject(object_id_t object,
-                                          HasHealthIF::HealthState initialState) {
+                                          HasHealthIF::HealthState initilialState) {
   if (healthMap.count(object) != 0) {
     return returnvalue::FAILED;
   }
-  healthMap.emplace(object, initialState);
+  healthMap.emplace(object, initilialState);
   return returnvalue::OK;
 }
 
@@ -112,5 +112,3 @@ ReturnValue_t HealthTable::iterate(HealthEntry* value, bool reset) {
   mapIterator++;
   return result;
 }
-
-MutexIF* HealthTable::getMutex() { return mutex; }

src/fsfw/health/HealthTable.h

@@ -18,7 +18,7 @@ class HealthTable : public HealthTableIF, public SystemObject {
 
   /** HealthTableIF overrides */
   virtual ReturnValue_t registerObject(
-      object_id_t object, HasHealthIF::HealthState initialState = HasHealthIF::HEALTHY) override;
+      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) override;
   ReturnValue_t removeObject(object_id_t object) override;
   virtual size_t getPrintSize() override;
   virtual void printAll(uint8_t* pointer, size_t maxSize) override;
@@ -28,8 +28,6 @@ class HealthTable : public HealthTableIF, public SystemObject {
   virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState) override;
   virtual HasHealthIF::HealthState getHealth(object_id_t) override;
 
-  MutexIF* getMutex();
-
  protected:
   using HealthMap = std::map<object_id_t, HasHealthIF::HealthState>;
   using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;

src/fsfw/health/HealthTableIF.h

@@ -12,7 +12,7 @@ class HealthTableIF : public ManagesHealthIF {
   virtual ~HealthTableIF() {}
 
   virtual ReturnValue_t registerObject(
-      object_id_t object, HasHealthIF::HealthState initialState = HasHealthIF::HEALTHY) = 0;
+      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;
 
   virtual ReturnValue_t removeObject(object_id_t objectId) = 0;
 

src/fsfw/housekeeping/Dataset.h

@@ -91,7 +91,7 @@ class Dataset : public SerializeIF {
 
   void setChildrenValidity(bool valid) {
     for (auto &serializable : serializables) {
-      serializable.get().setValid(valid);
+      serializable.get().setValid(true);
     }
   }
 

src/fsfw/housekeeping/PeriodicHkHelper.cpp

@@ -9,6 +9,7 @@
 #include "fsfw/housekeeping/HousekeepingSnapshot.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/timemanager/CCSDSTime.h"
 
 using namespace hk;
 
@@ -83,7 +84,6 @@ ReturnValue_t PeriodicHelper::performHkOperation() {
 
 ReturnValue_t PeriodicHelper::handleHousekeepingMessage(CommandMessage* message) {
   Command_t command = message->getCommand();
-  MessageQueueId_t sender = message->getSender();
   dp::sid_t sid = HousekeepingMessage::getStructureId(message);
   ReturnValue_t result = returnvalue::OK;
   switch (command) {
@@ -113,7 +113,7 @@ ReturnValue_t PeriodicHelper::handleHousekeepingMessage(CommandMessage* message)
     }
 
     case (HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT): {
-      return generateHousekeepingPacket(HousekeepingMessage::getStructureId(message), sender);
+      return generateHousekeepingPacket(HousekeepingMessage::getStructureId(message));
     }
 
     default:

src/fsfw/objectmanager/frameworkObjects.h

@@ -36,8 +36,6 @@ enum framework_objects : object_id_t {
   TIME_STAMPER = 0x53500010,
   VERIFICATION_REPORTER = 0x53500020,
 
-  SIF_PRINT_TASK = 0x53600000,
-
   FSFW_OBJECTS_END = 0x53ffffff,
   NO_OBJECT = 0xFFFFFFFF
 };

src/fsfw/osal/common/UdpTcPollingTask.cpp

@@ -41,7 +41,7 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid
 
 [[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
   /* Sender Address is cached here. */
-  struct sockaddr senderAddress{};
+  struct sockaddr senderAddress {};
   socklen_t senderAddressSize = sizeof(senderAddress);
 
   /* Poll for new UDP datagrams in permanent loop. */

src/fsfw/osal/freertos/Clock.cpp

@@ -5,8 +5,8 @@
 
 #include "FreeRTOS.h"
 #include "fsfw/globalfunctions/timevalOperations.h"
-#include "fsfw/osal/freertos/Timekeeper.h"
 #include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
+#include "fsfw/osal/freertos/Timekeeper.h"
 #include "task.h"
 
 // TODO sanitize input?
@@ -48,7 +48,7 @@ ReturnValue_t Clock::getClock(timeval* time) {
 }
 
 ReturnValue_t Clock::getClockMonotonic(timeval* time) {
-  *time = Timekeeper::instance()->getMonotonicClockOffset() + getUptime();
+	*time = Timekeeper::instance()->getMonotonicClockOffset() + getUptime();
   return returnvalue::OK;
 }
 

src/fsfw/osal/freertos/Timekeeper.cpp

@@ -18,11 +18,11 @@ Timekeeper* Timekeeper::instance() {
 }
 
 void Timekeeper::setOffset(const timeval& offset) {
-  if (not monotonicClockInitialized) {
-    this->monotonicClockOffset = offset;
-    monotonicClockInitialized = true;
-  }
-  this->offset = offset;
+	if (not monotonicClockInitialized) {
+		this->monotonicClockOffset = offset;
+		monotonicClockInitialized = true;
+	}
+	this->offset = offset;
 }
 
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
@@ -40,4 +40,6 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 
 TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); }
 
-const timeval Timekeeper::getMonotonicClockOffset() const { return monotonicClockOffset; }
+const timeval Timekeeper::getMonotonicClockOffset() const {
+	return monotonicClockOffset;
+}

src/fsfw/osal/host/Clock.cpp

@@ -173,7 +173,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 }
 
 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  struct tm time_tm{};
+  struct tm time_tm {};
 
   time_tm.tm_year = from->year - 1900;
   time_tm.tm_mon = from->month - 1;

src/fsfw/osal/host/TaskFactory.cpp

@@ -52,6 +52,6 @@ void TaskFactory::printMissedDeadline() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
 #else
-  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name.c_str());
+  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 }

src/fsfw/pus/Service11TelecommandScheduling.h

@@ -49,7 +49,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
 
   //! [EXPORT] : [COMMENT] Deletion of a TC from the map failed.
   //! P1: First 32 bit of request ID, P2. Last 32 bit of Request ID
-  static constexpr Event TC_DELETION_FAILED = event::makeEvent<SUBSYSTEM_ID, 0, severity::MEDIUM>();
+  static constexpr Event TC_DELETION_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
 
   // The types of PUS-11 subservices
   enum Subservice : uint8_t {

src/fsfw/pus/Service5EventReporting.cpp

@@ -44,7 +44,7 @@ ReturnValue_t Service5EventReporting::performService() {
 }
 
 ReturnValue_t Service5EventReporting::generateEventReport(EventMessage message) {
-  EventReport report(message.getEventId(), message.getReporter(), message.getParameter1(),
+  EventReport report(message.getEvent(), message.getReporter(), message.getParameter1(),
                      message.getParameter2());
   storeHelper.preparePacket(psbParams.serviceId, message.getSeverity(), tmHelper.sendCounter);
   storeHelper.setSourceDataSerializable(report);

src/fsfw/pus/Service8FunctionManagement.h

@@ -1,8 +1,6 @@
 #ifndef FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 
-#include <cstdint>
-
 #include "fsfw/action/ActionMessage.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 
@@ -37,13 +35,6 @@ class Service8FunctionManagement : public CommandingServiceBase {
                              uint16_t commandTimeoutSeconds = 60);
   ~Service8FunctionManagement() override;
 
-  enum class Subservice : uint8_t {
-    //!< [EXPORT] : [COMMAND] Functional commanding
-    COMMAND_DIRECT_COMMANDING = 128,
-    //!< [EXPORT] : [REPLY] Data reply
-    REPLY_DIRECT_COMMANDING_DATA = 130,
-  };
-
  protected:
   /* CSB abstract functions implementation . See CSB documentation. */
   ReturnValue_t isValidSubservice(uint8_t subservice) override;
@@ -57,6 +48,13 @@ class Service8FunctionManagement : public CommandingServiceBase {
                             bool* isStep) override;
 
  private:
+  enum class Subservice {
+    //!< [EXPORT] : [COMMAND] Functional commanding
+    COMMAND_DIRECT_COMMANDING = 128,
+    //!< [EXPORT] : [REPLY] Data reply
+    REPLY_DIRECT_COMMANDING_DATA = 130,
+  };
+
   ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t* messageQueueToSet,
                                                      object_id_t* objectId);
   ReturnValue_t prepareDirectCommand(CommandMessage* message, const uint8_t* tcData,

src/fsfw/pus/servicepackets/Service5Packets.h

@@ -17,17 +17,13 @@
  */
 class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
  public:
-  EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-              uint32_t parameter2_)
-      : reportId(reportId_),
-        objectId(objectId_),
-        parameter1(parameter1_),
-        parameter2(parameter2_) {}
+  EventReport(Event event_, object_id_t objectId_, uint32_t parameter1_, uint32_t parameter2_)
+      : event(event_), objectId(objectId_), parameter1(parameter1_), parameter2(parameter2_) {}
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           SerializeIF::Endianness streamEndianness) const override {
     ReturnValue_t result =
-        SerializeAdapter::serialize(&reportId, buffer, size, maxSize, streamEndianness);
+        SerializeAdapter::serialize(&event, buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
       return result;
     }
@@ -48,7 +44,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
 
   size_t getSerializedSize() const override {
     uint32_t size = 0;
-    size += SerializeAdapter::getSerializedSize(&reportId);
+    size += SerializeAdapter::getSerializedSize(&event);
     size += SerializeAdapter::getSerializedSize(&objectId);
     size += SerializeAdapter::getSerializedSize(&parameter1);
     size += SerializeAdapter::getSerializedSize(&parameter2);
@@ -61,7 +57,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
   }
 
  private:
-  EventId_t reportId;
+  Event event;
   object_id_t objectId;
   uint32_t parameter1;
   uint32_t parameter2;

src/fsfw/pus/servicepackets/Service8Packets.h

@@ -1,14 +1,11 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 
-#include <cstdint>
-
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
-#include "../../returnvalues/returnvalue.h"
 #include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
 #include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeAdapter.h"
 #include "../../serialize/SerializeElement.h"
 
 /**
@@ -25,41 +22,14 @@ class DirectCommand
     parametersSize = size;
   }
 
-  DirectCommand() : parametersSize(0), parameterBuffer(nullptr) {}
-
   ActionId_t getActionId() const { return actionId; }
-  void setActionId(ActionId_t actionId) { this->actionId = actionId; }
 
   object_id_t getObjectId() const { return objectId; }
-  void setObjectId(object_id_t objectId) { this->objectId = objectId; }
 
   const uint8_t* getParameters() { return parameterBuffer; }
-  // The given pointer is not deallocated and must outlive the DirectCommand!
-  void setParameters(const uint8_t* parameters, uint32_t parametersSize) {
-    this->parameterBuffer = parameters;
-    this->parametersSize = parametersSize;
-  }
 
   uint32_t getParametersSize() const { return parametersSize; }
 
-  // ^SerializeIF
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override {
-    auto const oldSize = *size;
-    auto result = SerializeAdapter::serialize(&objectId, buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) return result;
-    result = SerializeAdapter::serialize(&actionId, buffer, size, maxSize - ((*size) - oldSize),
-                                         streamEndianness);
-    if (result != returnvalue::OK) return result;
-
-    auto remainingSize = maxSize - ((*size) - oldSize);
-    if (remainingSize < parametersSize) return returnvalue::FAILED;
-    memcpy(*buffer, parameterBuffer, parametersSize);
-    *size += parametersSize;
-
-    return returnvalue::OK;
-  }
-
  private:
   DirectCommand(const DirectCommand& command);
   object_id_t objectId = 0;

src/fsfw/serviceinterface/CMakeLists.txt

@@ -1,5 +1,4 @@
 target_sources(
   ${LIB_FSFW_NAME}
   PRIVATE ServiceInterfaceStream.cpp ServiceInterfaceBuffer.cpp
-          ServiceInterfacePrinter.cpp ServiceInterfacePrinterTask.cpp
-          ServiceInterfacePrinterMessage.cpp)
+          ServiceInterfacePrinter.cpp)

src/fsfw/serviceinterface/ServiceInterfacePrinter.cpp

@@ -1,13 +1,9 @@
 #include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
 
 #include <cstdarg>
+#include <cstdint>
 
-#include "ServiceInterfacePrinterMessage.h"
-#include "etl/bitset.h"
-#include "etl/queue.h"
 #include "fsfw/FSFW.h"
-#include "fsfw/ipc/MutexGuard.h"
-#include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/timemanager/Clock.h"
 
@@ -18,33 +14,11 @@ static bool consoleInitialized = false;
 
 #if FSFW_DISABLE_PRINTOUT == 0
 
-typedef etl::bitset<fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT> bitset;
-
 static bool addCrAtEnd = false;
-static bool initializedAndReady = false;
-static bool replaceLastCharWithNewline = false;
 
-bitset bufferState{};
-std::array<char[fsfwconfig::FSFW_PRINT_BUFFER_SIZE], fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT>
-    printBufferArray = {};
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];
 
-uint32_t droppedMessagesCounter = 0;
-uint32_t droppedMessagesCounterContinuous = 0;
-
-MutexIF* bufferMutex;
-MessageQueueIF* bufferQueue;
-
-size_t selectFreeBuffer() {
-  MutexGuard guard(bufferMutex, MutexIF::TimeoutType::WAITING, 10);
-  const size_t bufferIdx = bufferState.find_first(false);
-  if (bufferIdx == bitset::npos) {
-    return bitset::npos;
-  }
-  bufferState.set(bufferIdx, true);
-  return bufferIdx;
-}
-
-void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
+void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
   if (not consoleInitialized) {
     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -56,22 +30,14 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
   consoleInitialized = true;
 #endif
 
+  size_t len = 0;
+  char *bufferPosition = reinterpret_cast<char *>(printBuffer);
+
   /* Check logger level */
   if (printType == sif::PrintLevel::NONE or printType > printLevel) {
     return;
   }
 
-  const bool isReady = initializedAndReady;
-  const size_t bufferIdx = isReady ? selectFreeBuffer() : 0;
-  if (bufferIdx == bitset::npos) {
-    // This will lose updates, but we are mostly concerned with if we are dropping messages
-    ++droppedMessagesCounter;
-    return;
-  }
-
-  size_t len = 0;
-  char* bufferPosition = printBufferArray[bufferIdx];
-
   /* Log message to terminal */
 
 #if FSFW_COLORED_OUTPUT == 1
@@ -95,6 +61,7 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
   if (printType == sif::PrintLevel::WARNING_LEVEL) {
     len += sprintf(bufferPosition + len, "WARNING");
   }
+
   if (printType == sif::PrintLevel::ERROR_LEVEL) {
     len += sprintf(bufferPosition + len, "ERROR  ");
   }
@@ -112,108 +79,51 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
                  (unsigned long)now.minute, (unsigned long)now.second,
                  (unsigned long)now.usecond / 1000);
 
-  len += vsnprintf(bufferPosition + len, sizeof(printBufferArray[bufferIdx]) - len, fmt, arg);
+  len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);
 
   if (addCrAtEnd) {
     len += sprintf(bufferPosition + len, "\r");
   }
 
-  printBufferArray[bufferIdx][fsfwconfig::FSFW_PRINT_BUFFER_SIZE - 1] = 0;
-
-  if (replaceLastCharWithNewline) {
-    const size_t stringLength = strlen(bufferPosition);
-    const size_t lastCharPosition =
-        etl::min(stringLength - 1, fsfwconfig::FSFW_PRINT_BUFFER_SIZE - 3);
-    const char lastChar = printBufferArray[bufferIdx][lastCharPosition];
-    if (!(lastChar == '\n' or lastChar == '\r')) {
-      printBufferArray[bufferIdx][lastCharPosition + 1] = '\n';
-      printBufferArray[bufferIdx][lastCharPosition + 2] = 0;
-    }
-  }
-
-  if (isReady) {
-    ServiceInterfacePrinterMessage message(bufferIdx);
-    bufferQueue->sendToDefault(&message);
-  } else {
-    printf("%s", printBufferArray[bufferIdx]);
-  }
+  printf("%s", printBuffer);
 }
 
-void sif::setToAddCrAtEnd(const bool addCrAtEnd_) { addCrAtEnd = addCrAtEnd_; }
-
-void sif::setReplaceLastCharWithNewline(const bool replace) {
-  replaceLastCharWithNewline = replace;
-}
-
-void sif::printInfo(const char* fmt, ...) {
+void sif::printInfo(const char *fmt, ...) {
   va_list args;
   va_start(args, fmt);
   fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
   va_end(args);
 }
 
-void sif::printWarning(const char* fmt, ...) {
+void sif::printWarning(const char *fmt, ...) {
   va_list args;
   va_start(args, fmt);
   fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
   va_end(args);
 }
 
-void sif::printDebug(const char* fmt, ...) {
+void sif::printDebug(const char *fmt, ...) {
   va_list args;
   va_start(args, fmt);
   fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
   va_end(args);
 }
 
-void sif::printError(const char* fmt, ...) {
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) { addCrAtEnd = addCrAtEnd_; }
+
+void sif::printError(const char *fmt, ...) {
   va_list args;
   va_start(args, fmt);
   fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
   va_end(args);
 }
 
-void sif::printCallback() {
-  if (!initializedAndReady) {
-    initializedAndReady = true;
-  }
-  uint32_t bitmask = 0;
-  ServiceInterfacePrinterMessage message;
-  while (bufferQueue->receiveMessage(&message) == returnvalue::OK) {
-    const size_t bufferIdx = message.getBufferIndex();
-    bitmask |= 1 << bufferIdx;
-    printf("%s", printBufferArray[bufferIdx]);
-  }
-  {
-    MutexGuard guard(bufferMutex, MutexIF::TimeoutType::BLOCKING);
-    bufferState &= ~bitmask;
-  }
-  const uint32_t droppedMessages = droppedMessagesCounter;
-  droppedMessagesCounter = 0;
-  droppedMessagesCounterContinuous += droppedMessages;
-  if (droppedMessages != 0) {
-    sif::printError("ServiceInterfacePrinter: Dropped ca. %i messages\n", droppedMessages);
-  }
-}
-
-void sif::init() {
-  bufferMutex = MutexFactory::instance()->createMutex();
-  bufferQueue = QueueFactory::instance()->createMessageQueue(fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT);
-  bufferQueue->setDefaultDestination(bufferQueue->getId());
-}
-
-uint32_t sif::getDroppedMessagesCount() { return droppedMessagesCounterContinuous; }
-
 #else
 
-void sif::printInfo(const char* fmt, ...) {}
-void sif::printWarning(const char* fmt, ...) {}
-void sif::printDebug(const char* fmt, ...) {}
-void sif::printError(const char* fmt, ...) {}
-
-void sif::printCallback() {}
-void sif::init() {}
-uint32_t sif::getDroppedMessagesCount() { return 0; }
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}
 
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 

src/fsfw/serviceinterface/ServiceInterfacePrinter.h

@@ -39,11 +39,6 @@ PrintLevel getPrintLevel();
 
 void setToAddCrAtEnd(bool addCrAtEnd_);
 
-/**
- * Replaces the last char of a print buffer with a newline
- */
-void setReplaceLastCharWithNewline(bool replace);
-
 /**
  * These functions can be used like the C stdio printf and forward the
  * supplied formatted string arguments to a printf function.
@@ -56,21 +51,6 @@ void printWarning(const char* fmt, ...);
 void printDebug(const char* fmt, ...);
 void printError(const char* fmt, ...);
 
-/**
- * This function is to be called periodically by a dedicated print task.
- */
-void printCallback();
-
-/**
- * Initializes the global state for the print task.
- */
-void init();
-
-/**
- * Gets the total estimated number of dropped messages
- */
-uint32_t getDroppedMessagesCount();
-
 }  // namespace sif
 
 #endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER */

src/fsfw/serviceinterface/ServiceInterfacePrinterMessage.cpp

@@ -1,18 +0,0 @@
-#include "ServiceInterfacePrinterMessage.h"
-
-#include <cstring>
-
-ServiceInterfacePrinterMessage::ServiceInterfacePrinterMessage(const size_t bufferIdx) {
-  this->MessageQueueMessage::setMessageSize(sizeof(bufferIdx));
-  this->setBufferIndex(bufferIdx);
-}
-
-void ServiceInterfacePrinterMessage::setBufferIndex(const size_t bufferIdx) {
-  std::memcpy(this->getData(), &bufferIdx, sizeof(bufferIdx));
-}
-
-size_t ServiceInterfacePrinterMessage::getBufferIndex() {
-  size_t tempIdx;
-  std::memcpy(&tempIdx, this->getData(), sizeof(size_t));
-  return tempIdx;
-}

src/fsfw/serviceinterface/ServiceInterfacePrinterMessage.h

@@ -1,12 +0,0 @@
-#pragma once
-#include "fsfw/ipc/MessageQueueMessage.h"
-
-class ServiceInterfacePrinterMessage : public MessageQueueMessage {
- public:
-  ServiceInterfacePrinterMessage() = default;
-  explicit ServiceInterfacePrinterMessage(size_t bufferIdx);
-  size_t getBufferIndex();
-
- private:
-  void setBufferIndex(size_t bufferIdx);
-};

src/fsfw/serviceinterface/ServiceInterfacePrinterTask.cpp

@@ -1,14 +0,0 @@
-#include "ServiceInterfacePrinterTask.h"
-
-#include "ServiceInterfacePrinter.h"
-#include "fsfw/objectmanager/SystemObject.h"
-
-ServiceInterfacePrinterTask::ServiceInterfacePrinterTask(object_id_t objectId)
-    : SystemObject(objectId) {
-  sif::init();
-}
-
-ReturnValue_t ServiceInterfacePrinterTask::performOperation(uint8_t operationCode) {
-  sif::printCallback();
-  return returnvalue::OK;
-}

src/fsfw/serviceinterface/ServiceInterfacePrinterTask.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-class ServiceInterfacePrinterTask : public ExecutableObjectIF, public SystemObject {
- public:
-  explicit ServiceInterfacePrinterTask(object_id_t objectId);
-  ReturnValue_t performOperation(uint8_t operationCode) override;
-};

src/fsfw/subsystem/Subsystem.h

@@ -99,7 +99,7 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
     EntryPointer entries;
   };
 
-  static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 100;
+  static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;
 
   static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;
 

src/fsfw/subsystem/SubsystemBase.cpp

@@ -78,8 +78,9 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
       submodeToCommand = targetSubmode;
     }
 
-    if (healthHelper.healthTable->hasHealth(convertToDeviceObjectId(object))) {
-      switch (healthHelper.healthTable->getHealth(convertToDeviceObjectId(object))) {
+    if (healthHelper.healthTable->hasHealth(object)) {
+
+      switch (healthHelper.healthTable->getHealth(object)) {
         case NEEDS_RECOVERY:
         case FAULTY:
         case PERMANENT_FAULTY:
@@ -352,5 +353,3 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t childObjectId, MessageQue
   }
   return returnvalue::OK;
 }
-
-object_id_t SubsystemBase::convertToDeviceObjectId(object_id_t id) { return id; }

src/fsfw/subsystem/SubsystemBase.h

@@ -113,8 +113,8 @@ class SubsystemBase : public SystemObject,
    * We need to know the target Submode, as children are able to inherit the submode
    * Still, we have a default for all child implementations which do not use submode inheritance
    */
-  virtual void executeTable(HybridIterator<ModeListEntry> tableIter,
-                            Submode_t targetSubmode = SUBMODE_NONE);
+  void executeTable(HybridIterator<ModeListEntry> tableIter,
+                    Submode_t targetSubmode = SUBMODE_NONE);
 
   ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode, Submode_t submode);
   ReturnValue_t updateChildModeByObjId(object_id_t objectId, Mode_t mode, Submode_t submode);
@@ -153,12 +153,6 @@ class SubsystemBase : public SystemObject,
   virtual void announceMode(bool recursive) override;
 
   virtual void modeChanged();
-
-  /**
-   * @brief Provides an adaptation point for the user to change an objectId into
-   * a different objectId.
-   */
-  virtual object_id_t convertToDeviceObjectId(object_id_t id);
 };
 
 #endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */

src/fsfw/tcdistribution/PusDistributor.cpp

@@ -18,10 +18,6 @@ PusDistributor::PusDistributor(uint16_t setApid, object_id_t setObjectId, Storag
 
 PusDistributor::~PusDistributor() = default;
 
-void PusDistributor::setVerificationReporter(object_id_t verificationReporter_) {
-  verificationReporter = verificationReporter_;
-}
-
 ReturnValue_t PusDistributor::selectDestination(MessageQueueId_t& destId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
   store_address_t storeId = currentMessage.getStorageId();
@@ -135,7 +131,8 @@ ReturnValue_t PusDistributor::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
   if (verifyChannel == nullptr) {
-    verifyChannel = ObjectManager::instance()->get<VerificationReporterIF>(verificationReporter);
+    verifyChannel =
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
     if (verifyChannel == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }

src/fsfw/tcdistribution/PusDistributor.h

@@ -43,10 +43,6 @@ class PusDistributor : public TcDistributorBase,
   [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
   ReturnValue_t initialize() override;
   [[nodiscard]] uint32_t getIdentifier() const override;
-  /**
-   * @brief Can be used to set the verification reporter if another than the default should be used
-   */
-  void setVerificationReporter(object_id_t verificationReporter_);
 
  protected:
   struct ServiceInfo {
@@ -79,8 +75,6 @@ class PusDistributor : public TcDistributorBase,
    */
   ReturnValue_t tcStatus;
 
-  object_id_t verificationReporter = objects::VERIFICATION_REPORTER;
-
   /**
    * This method reads the packet service, checks if such a service is
    * registered and forwards the packet to the destination.

src/fsfw/tcdistribution/definitions.h

@@ -25,7 +25,7 @@ static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(11)
 
 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TMTC_DISTRIBUTION;
 //! P1: Returnvalue, P2: 0 for TM issues, 1 for TC issues
-static constexpr Event HANDLE_PACKET_FAILED = event::makeEvent<SUBSYSTEM_ID, 0, severity::LOW>();
+static constexpr Event HANDLE_PACKET_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::LOW);
 
 };  // namespace tmtcdistrib
 #endif  // FSFW_TMTCPACKET_DEFINITIONS_H

src/fsfw/tmstorage/TmStoreMessage.cpp

@@ -114,11 +114,6 @@ void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd, store_ad
   cmd->setParameter2(storeId.raw);
 }
 
-void TmStoreMessage::setStopDownlinkContentMessage(CommandMessage* cmd, store_address_t storeId) {
-  cmd->setCommand(STOP_DOWNLINK_STORE_CONTENT);
-  cmd->setParameter2(storeId.raw);
-}
-
 uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd) { return cmd->getParameter(); }
 uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd) { return cmd->getParameter2(); }
 

src/fsfw/tmstorage/TmStoreMessage.h

@@ -21,7 +21,6 @@ class TmStoreMessage {
   static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
                                              store_address_t storeId);
   static void setDownlinkContentTimeMessage(CommandMessage* cmd, store_address_t storeId);
-  static void setStopDownlinkContentMessage(CommandMessage* cmd, store_address_t storeId);
   static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
   static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow,
                                               uint32_t addressHigh);
@@ -55,7 +54,6 @@ class TmStoreMessage {
   static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
   static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
   static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-  static const Command_t STOP_DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(15);
 
  private:
   TmStoreMessage();

src/fsfw/tmtcservices/CommandingServiceBase.cpp

@@ -128,7 +128,7 @@ ReturnValue_t CommandingServiceBase::initialize() {
 
   if (verificationReporter == nullptr) {
     verificationReporter =
-        ObjectManager::instance()->get<VerificationReporterIF>(verificationReporterId);
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
     if (verificationReporter == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
@@ -136,10 +136,6 @@ ReturnValue_t CommandingServiceBase::initialize() {
   return returnvalue::OK;
 }
 
-void CommandingServiceBase::setVerificationReporter(object_id_t verificationReporterId_) {
-  verificationReporterId = verificationReporterId_;
-}
-
 void CommandingServiceBase::handleCommandQueue() {
   CommandMessage reply;
   ReturnValue_t result;

src/fsfw/tmtcservices/CommandingServiceBase.h

@@ -126,8 +126,6 @@ class CommandingServiceBase : public SystemObject,
 
   ReturnValue_t initialize() override;
 
-  void setVerificationReporter(object_id_t verificationReporterId_);
-
   /**
    * Implementation of ExecutableObjectIF function
    *
@@ -264,8 +262,6 @@ class CommandingServiceBase : public SystemObject,
 
   const uint16_t timeoutSeconds;
 
-  object_id_t verificationReporterId = objects::VERIFICATION_REPORTER;
-
   PusTcReader tcReader;
   TmStoreHelper tmStoreHelper;
   TmSendHelper tmSendHelper;

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -111,7 +111,7 @@ ReturnValue_t PusServiceBase::initialize() {
   }
 
   if (psbParams.pusDistributor == nullptr) {
-    psbParams.pusDistributor = ObjectManager::instance()->get<PusDistributorIF>(pusDistributor);
+    psbParams.pusDistributor = ObjectManager::instance()->get<PusDistributorIF>(PUS_DISTRIBUTOR);
     if (psbParams.pusDistributor != nullptr) {
       registerService(*psbParams.pusDistributor);
     }
@@ -126,7 +126,7 @@ ReturnValue_t PusServiceBase::initialize() {
 
   if (psbParams.verifReporter == nullptr) {
     psbParams.verifReporter =
-        ObjectManager::instance()->get<VerificationReporterIF>(verificationReporter);
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
     if (psbParams.verifReporter == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
@@ -134,14 +134,6 @@ ReturnValue_t PusServiceBase::initialize() {
   return returnvalue::OK;
 }
 
-void PusServiceBase::setPusDistributor(object_id_t pusDistributor_) {
-  pusDistributor = pusDistributor_;
-}
-
-void PusServiceBase::setVerificationReporter(object_id_t verificationReporter_) {
-  verificationReporter = verificationReporter_;
-}
-
 void PusServiceBase::setTcPool(StorageManagerIF& tcPool) { psbParams.tcPool = &tcPool; }
 
 void PusServiceBase::setErrorReporter(InternalErrorReporterIF& errReporter_) {

src/fsfw/tmtcservices/PusServiceBase.h

@@ -201,9 +201,6 @@ class PusServiceBase : public ExecutableObjectIF,
   void setTaskIF(PeriodicTaskIF* taskHandle) override;
   [[nodiscard]] const char* getName() const override;
 
-  void setPusDistributor(object_id_t pusDistributor_);
-  void setVerificationReporter(object_id_t verificationReporter_);
-
  protected:
   /**
    * @brief   Handle to the underlying task
@@ -231,9 +228,6 @@ class PusServiceBase : public ExecutableObjectIF,
   static object_id_t PACKET_DESTINATION;
   static object_id_t PUS_DISTRIBUTOR;
 
-  object_id_t pusDistributor = PUS_DISTRIBUTOR;
-  object_id_t verificationReporter = objects::VERIFICATION_REPORTER;
-
  private:
   void handleRequestQueue();
 };

src/fsfw_hal/linux/CommandExecutor.h

@@ -116,7 +116,7 @@ class CommandExecutor {
   int currentFd = 0;
   bool printOutput = true;
   std::vector<char> readVec;
-  struct pollfd waiter{};
+  struct pollfd waiter {};
   SimpleRingBuffer* ringBuffer = nullptr;
   DynamicFIFO<uint16_t>* sizesFifo = nullptr;
 

unittests/tmtcpacket/testPusTmReader.cpp

@@ -38,7 +38,7 @@ TEST_CASE("PUS TM Reader", "[pus-tm-reader]") {
       readerPtr->setTimeReader(&timeStamperAndReader);
       deleteReader = true;
     }
-    REQUIRE(not*readerPtr);
+    REQUIRE(not *readerPtr);
     REQUIRE(readerPtr->isNull());
     REQUIRE(readerPtr->parseDataWithCrcCheck() == returnvalue::OK);
     REQUIRE(not readerPtr->isNull());