refactor task IF

Reviewed-on: #83

CHANGELOG.md

@@ -25,8 +25,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Devicehandlers: Periodic printout is run-time configurable now
 - `oneShotAction` flag in the `TestTask` class is not static anymore
-- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
 - Major update for version handling, using `git describe` to fetch version information with git.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/601
   - Place `Version` class outside of `fsfw` namespace. It is generic
@@ -45,12 +43,39 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   creation call. It allows passing context information and an arbitrary user argument into
   the message queue. Also streamlined and simplified `MessageQueue` implementation for all OSALs
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/583
-- Clock: 
-  - `timeval` to `TimeOfDay_t`
-  - Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
-  - Moved the statics used by Clock in ClockCommon.cpp to this file
-  - Better check for leap seconds
-  - Added Unittests for Clock (only getter)
+
+### HAL
+
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+- HAL Linux SPI: Set the Clock Default State when setting new SPI speed
+  and mode
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/573
+- GPIO HAL: `Direction`, `GpioOperation` and `Levels` are enum classes now, which prevents
+  name clashes with Windows defines.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585
+
+### Time
+
+PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/584 and
+https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
+
+- `timeval` to `TimeOfDay_t`
+- Added Mutex for gmtime calls: (compare http://www.opengate.at/blog/2020/01/timeless/)
+- Moved the statics used by Clock in ClockCommon.cpp to this file
+- Better check for leap seconds
+- Added Unittests for Clock (only getter)
+
+### Power 
+
+- `PowerSwitchIF`: Remove `const` specifier from `sendSwitchCommand` and `sendFuseOnCommand` and
+  also specify a `ReturnValue_t` return type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- Extend `PowerSwitcher` module to optionally check current state when calling `turnOn` or
+  `turnOff`. Tis can be helpful to avoid commanding switches which do not need commanding
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 
 ## Removed
 
@@ -60,11 +85,29 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Additions
 
+- LTO support: Allow using LTO/IPO by setting `FSFW_ENABLE_LTO=1`. CMake is able to detect whether
+  the user compiler supports IPO/LPO. LTO is on by default now. Most modern compilers support it,
+  can make good use of it and it usually makes the code faster and/or smaller.
+  After some more research:
+  Enabling LTO will actually cause the compiler to only produce thin LTO by adding 
+  `-flto -fno-fat-lto-objects` to the compiler options. I am not sure this is an ideal choice
+  because if an application linking against the FSFW does not use LTO, there can be compile
+  issues (e.g. observed when compiling the FSFW tests without LTO). This is a known issue as
+  can be seen in the multiple CMake issues for it: 
+    - https://gitlab.kitware.com/cmake/cmake/-/issues/22913, 
+    - https://gitlab.kitware.com/cmake/cmake/-/issues/16808, 
+    - https://gitlab.kitware.com/cmake/cmake/-/issues/21696
+  Easiest solution for now: Keep this option OFF by default.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
   inside `fsfw/version.h`
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
 - Added ETL dependency and improved library dependency management
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/592
+- Add a `DummyPowerSwitcher` module which can be useful for test setups when no PCDU is available
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
+- New typedef for switcher type
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries
 
 ## HAL

CMakeLists.txt

@@ -18,11 +18,12 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" )
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake-modules")
 set(MSG_PREFIX "fsfw |")
 
+set(FSFW_ETL_LIB_NAME etl)
 set(FSFW_ETL_LIB_MAJOR_VERSION 20 CACHE STRING
-    "ETL library major version requirement"
+  "ETL library major version requirement"
 )
 set(FSFW_ETL_LIB_VERSION ${FSFW_ETL_LIB_MAJOR_VERSION}.27.3 CACHE STRING
-    "ETL library exact version requirement"
+  "ETL library exact version requirement"
 )
 set(FSFW_ETL_LINK_TARGET etl::etl)
 
@@ -33,19 +34,28 @@ set(FSFW_CATCH2_LIB_VERSION v${FSFW_CATCH2_LIB_MAJOR_VERSION}.0.0-preview5 CACHE
     "Catch2 library exact version requirement"
 )
 
-set(FSFW_ETL_LIB_NAME etl)
+# Keep this off by default for now. See PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/616
+# for information which keeping this on by default is problematic
+option(FSFW_ENABLE_IPO "Enable interprocedural optimization or link-time optimization if available" OFF)
+if(FSFW_ENABLE_IPO)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_ERROR)
+  if(NOT IPO_SUPPORTED)
+    message(STATUS "FSFW | IPO/LTO not supported: ${IPO_ERROR}")
+  endif()
+endif()
 
 option(FSFW_GENERATE_SECTIONS
-    "Generate function and data sections. Required to remove unused code" ON
+  "Generate function and data sections. Required to remove unused code" ON
 )
 if(FSFW_GENERATE_SECTIONS)
-    option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
+  option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()
 
 option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
 option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
 if(FSFW_BUILD_UNITTESTS)
-    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+  option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
 endif()
 
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
@@ -72,6 +82,10 @@ set(FSFW_DUMMY_TGT fsfw-dummy)
 
 add_library(${LIB_FSFW_NAME})
 
+if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+  set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+endif()
+
 set(FSFW_GIT_VER_HANDLING_OK FALSE)
 # Version handling
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
@@ -128,6 +142,9 @@ if(FSFW_BUILD_UNITTESTS)
 
     project(${FSFW_TEST_TGT} CXX C)
     add_executable(${FSFW_TEST_TGT})
+    if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
+      set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+    endif()
 
     if(FSFW_TESTS_GEN_COV)
         message(STATUS "${MSG_PREFIX} Generating coverage data for the library")

hal/src/fsfw_hal/linux/CommandExecutor.cpp

@@ -32,6 +32,8 @@ ReturnValue_t CommandExecutor::execute() {
   } else if (state == States::PENDING) {
     return COMMAND_PENDING;
   }
+  // Reset data in read vector
+  std::memset(readVec.data(), 0, readVec.size());
   currentCmdFile = popen(currentCmd.c_str(), "r");
   if (currentCmdFile == nullptr) {
     lastError = errno;
@@ -205,3 +207,5 @@ ReturnValue_t CommandExecutor::executeBlocking() {
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
+
+const std::vector<char>& CommandExecutor::getReadVector() const { return readVec; }

hal/src/fsfw_hal/linux/CommandExecutor.h

@@ -109,6 +109,8 @@ class CommandExecutor {
    */
   void reset();
 
+  const std::vector<char>& getReadVector() const;
+
  private:
   std::string currentCmd;
   bool blocking = true;

hal/src/fsfw_hal/linux/spi/SpiComIF.cpp

@@ -417,9 +417,7 @@ void SpiComIF::getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& spee
   }
 }
 
-const std::string& SpiComIF::getSpiDev() const {
-  return dev;
-}
+const std::string& SpiComIF::getSpiDev() const { return dev; }
 
 void SpiComIF::updateLinePolarity(int spiFd) {
   clockUpdateTransfer.len = 0;
@@ -428,3 +426,8 @@ void SpiComIF::updateLinePolarity(int spiFd) {
     utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Updating SPI default clock failed");
   }
 }
+
+void SpiComIF::setMutexParams(MutexIF::TimeoutType timeoutType_, uint32_t timeoutMs_) {
+  timeoutType = timeoutType_;
+  timeoutMs = timeoutMs_;
+}

hal/src/fsfw_hal/linux/spi/SpiComIF.h

@@ -22,15 +22,17 @@ class SpiCookie;
  */
 class SpiComIF : public DeviceCommunicationIF, public SystemObject {
  public:
-  static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
+  static constexpr dur_millis_t DEFAULT_MUTEX_TIMEOUT = 20;
+
+  static constexpr uint8_t CLASS_ID = CLASS_ID::HAL_SPI;
   static constexpr ReturnValue_t OPENING_FILE_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 0);
   /* Full duplex (ioctl) transfer failure */
   static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 1);
   /* Half duplex (read/write) transfer failure */
   static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
-      HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
+      HasReturnvaluesIF::makeReturnCode(CLASS_ID, 2);
 
   SpiComIF(object_id_t objectId, std::string devname, GpioIF* gpioComIF);
 
@@ -45,6 +47,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    *          the chip select must be driven from outside of the com if.
    */
   MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
+  void setMutexParams(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
   /**
    * Perform a regular send operation using Linux iotcl. This is public so it can be used
@@ -59,6 +62,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
 
   GpioIF* getGpioInterface();
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
+  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
 
   /**
    * This updates the SPI clock default polarity. Only setting the mode does not update
@@ -70,7 +74,6 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    * @param spiFd
    */
   void updateLinePolarity(int spiFd);
-  void getSpiSpeedAndMode(int spiFd, spi::SpiModes& mode, uint32_t& speed) const;
 
   const std::string& getSpiDev() const;
   void performSpiWiretapping(SpiCookie* spiCookie);
@@ -91,7 +94,7 @@ class SpiComIF : public DeviceCommunicationIF, public SystemObject {
    */
   MutexIF* csMutex = nullptr;
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-  uint32_t timeoutMs = 20;
+  uint32_t timeoutMs = DEFAULT_MUTEX_TIMEOUT;
   spi_ioc_transfer clockUpdateTransfer = {};
 
   using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -467,14 +467,14 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @brief 	This is a helper method to insert replies in the reply map.
    * @param deviceCommand	Identifier of the reply to add.
    * @param maxDelayCycles The maximum number of delay cycles the reply waits
-   * until it times out.
+   *    until it times out.
    * @param periodic	Indicates if the command is periodic (i.e. it is sent
-   * by the device repeatedly without request) or not. Default is aperiodic (0).
-   * Please note that periodic replies are disabled by default. You can enable them with
-   * #updatePeriodicReply
+   *    by the device repeatedly without request) or not. Default is aperiodic (0).
+   *    Please note that periodic replies are disabled by default. You can enable them with
+   *    #updatePeriodicReply
    * @param countdown Instead of using maxDelayCycles to timeout a device reply it is also possible
-   *                  to provide a pointer to a Countdown object which will signal the timeout
-   *                  when expired
+   *    to provide a pointer to a Countdown object which will signal the timeout
+   *    when expired
    * @return	- @c RETURN_OK when the command was successfully inserted,
    *          - @c RETURN_FAILED else.
    */
@@ -783,11 +783,18 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * This is used to keep track of pending replies.
    */
   struct DeviceReplyInfo {
+    //! For Command-Reply combinations:
     //! The maximum number of cycles the handler should wait for a reply
     //! to this command.
+    //!
+    //! Reply Only:
+    //! For periodic replies, this variable will be the number of delay cycles between the replies.
+    //! For the non-periodic variant, this variable is not used as there is no meaningful
+    //! definition for delay
     uint16_t maxDelayCycles;
-    //! The currently remaining cycles the handler should wait for a reply,
-    //! 0 means there is no reply expected
+    //! This variable will be set to #maxDelayCycles if a reply is expected.
+    //! For non-periodic replies without a command, this variable is unused.
+    //! A runtime value of 0 means there is no reply is currently expected.
     uint16_t delayCycles;
     size_t replyLen = 0;  //!< Expected size of the reply.
     //! if this is !=0, the delayCycles will not be reset to 0 but to

src/fsfw/health/HasHealthIF.h

@@ -16,10 +16,15 @@ class HasHealthIF {
   };
 
   static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
-  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);
+  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 1);
+  static constexpr ReturnValue_t INVALID_HEALTH_STATE =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 2);
+  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED =
+      HasReturnvaluesIF::makeReturnCode(INTERFACE_ID, 3);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER_1;
+  //! P1: New Health, P2: Old Health
   static const Event HEALTH_INFO = MAKE_EVENT(6, severity::INFO);
   static const Event CHILD_CHANGED_HEALTH = MAKE_EVENT(7, severity::INFO);
   static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);

src/fsfw/osal/linux/FixedTimeslotTask.cpp

@@ -14,6 +14,8 @@ FixedTimeslotTask::FixedTimeslotTask(const char* name_, int priority_, size_t st
 
 FixedTimeslotTask::~FixedTimeslotTask() {}
 
+bool FixedTimeslotTask::isEmpty() const { return pst.isEmpty(); }
+
 void* FixedTimeslotTask::taskEntryPoint(void* arg) {
   // The argument is re-interpreted as PollingTask.
   FixedTimeslotTask* originalTask(reinterpret_cast<FixedTimeslotTask*>(arg));
@@ -50,7 +52,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId, uint32_t slotT
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t FixedTimeslotTask::checkSequence() const { return pst.checkSequence(); }
+ReturnValue_t FixedTimeslotTask::checkSequence() { return pst.checkSequence(); }
 
 void FixedTimeslotTask::taskFunctionality() {
   // Like FreeRTOS pthreads are running as soon as they are created

src/fsfw/osal/linux/FixedTimeslotTask.h

@@ -24,15 +24,18 @@ class FixedTimeslotTask : public FixedTimeslotTaskIF, public PosixThread {
   FixedTimeslotTask(const char* name_, int priority_, size_t stackSize_, uint32_t periodMs_);
   virtual ~FixedTimeslotTask();
 
-  virtual ReturnValue_t startTask();
+  ReturnValue_t startTask() override;
 
-  virtual ReturnValue_t sleepFor(uint32_t ms);
+  ReturnValue_t sleepFor(uint32_t ms) override;
 
-  virtual uint32_t getPeriodMs() const;
+  uint32_t getPeriodMs() const override;
 
-  virtual ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs, int8_t executionStep);
+  ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
+                        int8_t executionStep) override;
 
-  virtual ReturnValue_t checkSequence() const;
+  ReturnValue_t checkSequence() override;
+
+  bool isEmpty() const override;
 
   /**
    * This static function can be used as #deadlineMissedFunc.

src/fsfw/osal/linux/PeriodicPosixTask.cpp

@@ -26,12 +26,12 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
   return NULL;
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object, uint8_t opCode) {
   ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
-  return addComponent(newObject);
+  return addComponent(newObject, opCode);
 }
 
-ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
+ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object, uint8_t opCode) {
   if (object == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
@@ -43,7 +43,7 @@ ReturnValue_t PeriodicPosixTask::addComponent(ExecutableObjectIF* object) {
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  objectList.push_back(object);
+  objectList.emplace(object, opCode);
   object->setTaskIF(this);
 
   return HasReturnvaluesIF::RETURN_OK;
@@ -54,6 +54,9 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 }
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
+  if (isEmpty()) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
   started = true;
   PosixThread::createTask(&taskEntryPoint, this);
   return HasReturnvaluesIF::RETURN_OK;
@@ -64,15 +67,13 @@ void PeriodicPosixTask::taskFunctionality(void) {
     suspend();
   }
 
-  for (auto const& object : objectList) {
-    object->initializeAfterTaskCreation();
-  }
+  initObjsAfterTaskCreation();
 
   uint64_t lastWakeTime = getCurrentMonotonicTimeMs();
   // The task's "infinite" inner loop is entered.
   while (1) {
-    for (auto const& object : objectList) {
-      object->performOperation();
+    for (auto const& objOpCodePair : objectList) {
+      objOpCodePair.first->performOperation(objOpCodePair.second);
     }
 
     if (not PosixThread::delayUntil(&lastWakeTime, periodMs)) {
@@ -84,3 +85,25 @@ void PeriodicPosixTask::taskFunctionality(void) {
 }
 
 uint32_t PeriodicPosixTask::getPeriodMs() const { return periodMs; }
+
+bool PeriodicPosixTask::isEmpty() const { return objectList.empty(); }
+
+ReturnValue_t PeriodicPosixTask::initObjsAfterTaskCreation() {
+  std::multiset<ExecutableObjectIF*> uniqueObjects;
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  uint32_t count = 0;
+  for (const auto& obj : objectList) {
+    // Ensure that each unique object is initialized once.
+    if (uniqueObjects.find(obj.first) == uniqueObjects.end()) {
+      ReturnValue_t result = obj.first->initializeAfterTaskCreation();
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        count++;
+        status = result;
+      }
+      uniqueObjects.emplace(obj.first);
+    }
+  }
+  if (count > 0) {
+  }
+  return status;
+}

src/fsfw/osal/linux/PeriodicPosixTask.h

@@ -1,7 +1,7 @@
 #ifndef FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
 #define FRAMEWORK_OSAL_LINUX_PERIODICPOSIXTASK_H_
 
-#include <vector>
+#include <set>
 
 #include "../../objectmanager/ObjectManagerIF.h"
 #include "../../tasks/ExecutableObjectIF.h"
@@ -40,7 +40,7 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * @param object Id of the object to add.
    * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  ReturnValue_t addComponent(object_id_t object) override;
+  ReturnValue_t addComponent(object_id_t object, uint8_t opCode) override;
 
   /**
    * Adds an object to the list of objects to be executed.
@@ -48,14 +48,20 @@ class PeriodicPosixTask : public PosixThread, public PeriodicTaskIF {
    * @param object pointer to the object to add.
    * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
+  ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode) override;
 
   uint32_t getPeriodMs() const override;
 
   ReturnValue_t sleepFor(uint32_t ms) override;
 
+  ReturnValue_t initObjsAfterTaskCreation();
+
+  bool isEmpty() const override;
+
  private:
-  typedef std::vector<ExecutableObjectIF*> ObjectList;  //!< Typedef for the List of objects.
+  //! Typedef for the List of objects. Will contain the objects to execute and their respective
+  //! op codes
+  using ObjectList = std::multiset<std::pair<ExecutableObjectIF*, uint8_t>>;
   /**
    * @brief	This attribute holds a list of objects to be executed.
    */

src/fsfw/power/DummyPowerSwitcher.cpp

@@ -1,8 +1,9 @@
 #include "DummyPowerSwitcher.h"
 
 DummyPowerSwitcher::DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches,
-                                       size_t numberOfFuses, uint32_t switchDelayMs)
-    : SystemObject(objectId),
+                                       size_t numberOfFuses, bool registerGlobally,
+                                       uint32_t switchDelayMs)
+    : SystemObject(objectId, registerGlobally),
       switcherList(numberOfSwitches),
       fuseList(numberOfFuses),
       switchDelayMs(switchDelayMs) {}

src/fsfw/power/DummyPowerSwitcher.h

@@ -8,10 +8,17 @@
 #include "definitions.h"
 #include "fsfw/objectmanager/SystemObject.h"
 
+/**
+ * @brief   This component can be used to simulate a power switcher like a
+ *          Power Control Distribution Unit (PCDU)
+ * @details
+ * The dummy switcher will simply cache the commanded fuse and switch states and return them
+ * in the according switch getter functions. In that sense, it simulates an ideal PCDU.
+ */
 class DummyPowerSwitcher : public SystemObject, public PowerSwitchIF {
  public:
   DummyPowerSwitcher(object_id_t objectId, size_t numberOfSwitches, size_t numberOfFuses,
-                     uint32_t switchDelayMs = 5000);
+                     bool registerGlobally = true, uint32_t switchDelayMs = 5000);
 
   void setInitialSwitcherList(std::vector<ReturnValue_t> switcherList);
   void setInitialFusesList(std::vector<ReturnValue_t> switcherList);

src/fsfw/power/PowerSwitcher.h

@@ -18,7 +18,8 @@ class PowerSwitcher : public HasReturnvaluesIF {
   static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
   static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
   static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
-  PowerSwitcher(PowerSwitchIF* switcher, uint8_t setSwitch1, uint8_t setSwitch2 = power::NO_SWITCH,
+  PowerSwitcher(PowerSwitchIF* switcher, power::Switch_t setSwitch1,
+                power::Switch_t setSwitch2 = power::NO_SWITCH,
                 State_t setStartState = SWITCH_IS_OFF);
   void turnOn(bool checkCurrentState = true);
   void turnOff(bool checkCurrentState = true);

src/fsfw/tasks/FixedSlotSequence.cpp

@@ -164,3 +164,5 @@ ReturnValue_t FixedSlotSequence::intializeSequenceAfterTaskCreation() const {
 void FixedSlotSequence::addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList&)) {
   this->customCheckFunction = customCheckFunction;
 }
+
+bool FixedSlotSequence::isEmpty() const { return slotList.empty(); }

src/fsfw/tasks/FixedSlotSequence.h

@@ -159,6 +159,8 @@ class FixedSlotSequence {
    */
   ReturnValue_t intializeSequenceAfterTaskCreation() const;
 
+  bool isEmpty() const;
+
  protected:
   /**
    * @brief	This list contains all PollingSlot objects, defining order and

src/fsfw/tasks/FixedTimeslotTaskIF.h

@@ -30,7 +30,7 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
    * Check whether the sequence is valid and perform all other required
    * initialization steps which are needed after task creation
    */
-  virtual ReturnValue_t checkSequence() const = 0;
+  virtual ReturnValue_t checkSequence() = 0;
 };
 
 #endif /* FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_ */

src/fsfw/tasks/PeriodicTaskIF.h

@@ -31,7 +31,7 @@ class PeriodicTaskIF {
    * Add an object to the task. The object needs to implement ExecutableObjectIF
    * @return
    */
-  virtual ReturnValue_t addComponent(object_id_t object) {
+  virtual ReturnValue_t addComponent(object_id_t object, uint8_t opCode = 0) {
     return HasReturnvaluesIF::RETURN_FAILED;
   };
 
@@ -41,13 +41,15 @@ class PeriodicTaskIF {
    * Add an object to the task.
    * @return
    */
-  virtual ReturnValue_t addComponent(ExecutableObjectIF* object) {
+  virtual ReturnValue_t addComponent(ExecutableObjectIF* object, uint8_t opCode = 0) {
     return HasReturnvaluesIF::RETURN_FAILED;
   };
 
   virtual ReturnValue_t sleepFor(uint32_t ms) = 0;
 
   virtual uint32_t getPeriodMs() const = 0;
+
+  virtual bool isEmpty() const = 0;
 };
 
 #endif /* PERIODICTASKIF_H_ */

tests/src/fsfw_tests/unit/CMakeLists.txt

@@ -11,7 +11,10 @@ target_sources(${FSFW_TEST_TGT} PRIVATE
 )
 
 add_subdirectory(testcfg)
+add_subdirectory(mocks)
+
 add_subdirectory(action)
+add_subdirectory(power)
 add_subdirectory(container)
 add_subdirectory(osal)
 add_subdirectory(serialize)

tests/src/fsfw_tests/unit/mocks/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	PowerSwitcherMock.cpp
+)

tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.cpp

@@ -0,0 +1,77 @@
+#include "PowerSwitcherMock.h"
+
+static uint32_t SWITCH_REQUEST_UPDATE_VALUE = 0;
+
+PowerSwitcherMock::PowerSwitcherMock() {}
+
+ReturnValue_t PowerSwitcherMock::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
+  if (switchMap.count(switchNr) == 0) {
+    switchMap.emplace(switchNr, SwitchInfo(switchNr, onOff));
+  } else {
+    SwitchInfo& info = switchMap.at(switchNr);
+    info.currentState = onOff;
+    if (onOff == PowerSwitchIF::SWITCH_ON) {
+      info.timesCalledOn++;
+    } else {
+      info.timesCalledOff++;
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherMock::sendFuseOnCommand(uint8_t fuseNr) {
+  if (fuseMap.count(fuseNr) == 0) {
+    fuseMap.emplace(fuseNr, FuseInfo(fuseNr));
+  } else {
+    FuseInfo& info = fuseMap.at(fuseNr);
+    info.timesCalled++;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherMock::getSwitchState(power::Switch_t switchNr) const {
+  if (switchMap.count(switchNr) == 1) {
+    auto& info = switchMap.at(switchNr);
+    SWITCH_REQUEST_UPDATE_VALUE++;
+    return info.currentState;
+  }
+  return RETURN_FAILED;
+}
+
+ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
+  if (fuseMap.count(fuseNr) == 1) {
+    return FUSE_ON;
+  } else {
+    return FUSE_OFF;
+  }
+  return RETURN_FAILED;
+}
+
+uint32_t PowerSwitcherMock::getSwitchDelayMs(void) const { return 5000; }
+
+SwitchInfo::SwitchInfo() : switcher(0) {}
+
+SwitchInfo::SwitchInfo(power::Switch_t switcher, ReturnValue_t initState)
+    : switcher(switcher), currentState(initState) {}
+
+FuseInfo::FuseInfo(uint8_t fuse) : fuse(fuse) {}
+
+void PowerSwitcherMock::getSwitchInfo(power::Switch_t switcher, SwitchInfo& info) {
+  if (switchMap.count(switcher) == 1) {
+    info = switchMap.at(switcher);
+  }
+}
+
+void PowerSwitcherMock::getFuseInfo(uint8_t fuse, FuseInfo& info) {
+  if (fuseMap.count(fuse) == 1) {
+    info = fuseMap.at(fuse);
+  }
+}
+
+uint32_t PowerSwitcherMock::getAmountSwitchStatWasRequested() {
+  return SWITCH_REQUEST_UPDATE_VALUE;
+}
+
+void PowerSwitcherMock::initSwitch(power::Switch_t switchNr) {
+  switchMap.emplace(switchNr, SwitchInfo(switchNr, PowerSwitchIF::SWITCH_OFF));
+}

tests/src/fsfw_tests/unit/mocks/PowerSwitcherMock.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
+#define FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
+
+#include <fsfw/power/PowerSwitchIF.h>
+
+#include <map>
+#include <utility>
+
+struct SwitchInfo {
+ public:
+  SwitchInfo();
+  SwitchInfo(power::Switch_t switcher, ReturnValue_t initState);
+
+  power::Switch_t switcher;
+  ReturnValue_t currentState = PowerSwitchIF::SWITCH_OFF;
+  uint32_t timesCalledOn = 0;
+  uint32_t timesCalledOff = 0;
+  uint32_t timesStatusRequested = 0;
+};
+
+struct FuseInfo {
+ public:
+  FuseInfo(uint8_t fuse);
+  uint8_t fuse;
+  uint32_t timesCalled = 0;
+};
+
+class PowerSwitcherMock : public PowerSwitchIF {
+ public:
+  PowerSwitcherMock();
+
+  ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
+  ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
+  ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
+  ReturnValue_t getFuseState(uint8_t fuseNr) const override;
+  uint32_t getSwitchDelayMs(void) const override;
+
+  void getSwitchInfo(power::Switch_t switcher, SwitchInfo& info);
+  void getFuseInfo(uint8_t fuse, FuseInfo& info);
+
+  uint32_t getAmountSwitchStatWasRequested();
+
+  void initSwitch(power::Switch_t switchNr);
+
+ private:
+  using SwitchOnOffPair = std::pair<power::Switch_t, ReturnValue_t>;
+  using FuseOnOffPair = std::pair<uint8_t, ReturnValue_t>;
+  std::map<power::Switch_t, SwitchInfo> switchMap;
+  std::map<uint8_t, FuseInfo> fuseMap;
+};
+
+#endif /* FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_ */

tests/src/fsfw_tests/unit/power/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    testPowerSwitcher.cpp
+)

tests/src/fsfw_tests/unit/power/testPowerSwitcher.cpp

@@ -0,0 +1,71 @@
+#include <fsfw/power/DummyPowerSwitcher.h>
+#include <fsfw/power/PowerSwitcher.h>
+#include <fsfw_tests/unit/mocks/PowerSwitcherMock.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "objects/systemObjectList.h"
+
+TEST_CASE("Power Switcher", "[power-switcher]") {
+  PowerSwitcherMock mock;
+  PowerSwitcher switcher(&mock, 1);
+  DummyPowerSwitcher dummySwitcher(objects::DUMMY_POWER_SWITCHER, 5, 5, false);
+  PowerSwitcher switcherUsingDummy(&dummySwitcher, 1);
+  SwitchInfo switchInfo;
+  mock.initSwitch(1);
+
+  SECTION("Basic Tests") {
+    REQUIRE(switcher.getFirstSwitch() == 1);
+    REQUIRE(switcher.getSecondSwitch() == power::NO_SWITCH);
+    // Default start state
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    switcher.turnOn(true);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 1);
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_ON);
+    REQUIRE(switcher.checkSwitchState() == PowerSwitcher::IN_POWER_TRANSITION);
+    REQUIRE(switcher.active());
+    switcher.doStateMachine();
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_ON);
+    mock.getSwitchInfo(1, switchInfo);
+    REQUIRE(switchInfo.timesCalledOn == 1);
+    REQUIRE(not switcher.active());
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 2);
+    REQUIRE(switcher.checkSwitchState() == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
+    switcher.turnOff(false);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
+    REQUIRE(switcher.active());
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
+    switcher.doStateMachine();
+    mock.getSwitchInfo(1, switchInfo);
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    REQUIRE(switchInfo.timesCalledOn == 1);
+    REQUIRE(switchInfo.timesCalledOff == 1);
+    REQUIRE(not switcher.active());
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 4);
+  }
+
+  SECTION("Dummy Test") {
+    // Same tests, but we can't really check the dummy
+    REQUIRE(switcherUsingDummy.getFirstSwitch() == 1);
+    REQUIRE(switcherUsingDummy.getSecondSwitch() == power::NO_SWITCH);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    switcherUsingDummy.turnOn(true);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_ON);
+    REQUIRE(switcherUsingDummy.active());
+    switcherUsingDummy.doStateMachine();
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_ON);
+    REQUIRE(not switcherUsingDummy.active());
+
+    switcherUsingDummy.turnOff(false);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
+    REQUIRE(switcherUsingDummy.active());
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
+    switcherUsingDummy.doStateMachine();
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    REQUIRE(not switcherUsingDummy.active());
+  }
+
+  SECTION("More Dummy Tests") {}
+}

tests/src/fsfw_tests/unit/testcfg/objects/systemObjectList.h

@@ -21,8 +21,9 @@ enum sourceObjects : uint32_t {
   HK_RECEIVER_MOCK = 22,
   TEST_LOCAL_POOL_OWNER_BASE = 25,
 
-  SHARED_SET_ID = 26
+  SHARED_SET_ID = 26,
 
+  DUMMY_POWER_SWITCHER = 27
 };
 }