Do not read me

Merge pull request 'v6.0.0' (#729 ) from development into master
Reviewed-on: fsfw/fsfw#729
2023-09-05 12:54:16 +02:00 · 2023-02-23 13:42:48 +01:00
52 changed files with 149 additions and 441 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -8,40 +8,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [unreleased]

-## Fixes
-
- The `PusTmCreator` API only accepted 255 bytes of source data. It can now accept source
-  data with a size limited only by the size of `size_t`.
- Important bugfix in CFDP PDU header format: The entity length field and the transaction sequence
-  number fields stored the actual length of the field instead of the length minus 1 like specified
-  in the CFDP standard.
- PUS Health Service: Size check for set health command.
-  Perform operation completion for announce health command.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/746
- Linux OSAL `getUptime` fix: Check validity of `/proc/uptime` file before reading uptime.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/745
- Small tweak for version getter
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/744
-
-## Added
-
- add CFDP subsystem ID
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
- `EventManager`: Add function to print all listeners.
-
-## Changed
-
- Bump ETL version to 20.35.14
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/748
- Renamed `PCDU_2` subsystem ID to `POWER_SWITCH_IF`.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
- Add new `PowerSwitchIF::SWITCH_UNKNOWN` returnvalue.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/743
- Assert that `FixedArrayList` is larger than 0 at compile time.
-  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/740
- `EventManager`: Queue depth is configurable now
- `ActionHelper`: Allow execution of actions without additional data
-
 # [v6.0.0] 2023-02-10

 ## Fixes
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -72,7 +72,7 @@ set(FSFW_ETL_LIB_MAJOR_VERSION
    20
    CACHE STRING "ETL library major version requirement")
 set(FSFW_ETL_LIB_VERSION
-    ${FSFW_ETL_LIB_MAJOR_VERSION}.36.0
+    ${FSFW_ETL_LIB_MAJOR_VERSION}.28.0
    CACHE STRING "ETL library exact version requirement")
 set(FSFW_ETL_LINK_TARGET etl::etl)

@ -80,7 +80,7 @@ set(FSFW_CATCH2_LIB_MAJOR_VERSION
    3
    CACHE STRING "Catch2 library major version requirement")
 set(FSFW_CATCH2_LIB_VERSION
-    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.3.2
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.1.0
    CACHE STRING "Catch2 library exact version requirement")

 # Keep this off by default for now. See PR:
--- a/README.md
+++ b/README.md
@ -1,208 +1 @@
-![FSFW Logo](misc/logo/FSFW_Logo_V3_bw.png)
-
-# Flight Software Framework (FSFW)
-
-The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
-automated systems like Satellites. 
-
-The initial version of the Flight Software Framework was developed during
-the Flying Laptop Project by the University of Stuttgart in cooperation
-with Airbus Defence and Space GmbH.
-
-## Quick facts
-
-The framework is designed for systems, which communicate with external devices, perform control loops, 
-receive telecommands and send telemetry, and need to maintain a high level of availability. Therefore,
-a mode and health system provides control over the states of the software and the controlled devices.
-In addition, a simple mechanism of event based fault detection, isolation and recovery is implemented as well. 
-
-The FSFW provides abstraction layers for operating systems to provide a uniform operating system
-abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is
-also very useful for developers to implement the same application logic on different operating
-systems with a uniform interface.
-
-Currently, the FSFW provides the following OSALs:
-
- Linux
- Host 
- FreeRTOS
- RTEMS
-
-The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile
-memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a
-ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the
-STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active
-satellite mission Flying Laptop.
-
-## Getting started
-
-The [Hosted FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted) provides a
-good starting point and a demo to see the FSFW capabilities.
-It is recommended to get started by building and playing around with the demo application.
-There are also other examples provided for all OSALs using the popular embedded platforms
-Raspberry Pi, Beagle Bone Black and STM32H7.
-
-Generally, the FSFW is included in a project by providing
-a configuration folder, building the static library and linking against it. 
-There are some functions like `printChar` which are different depending on the target architecture
-and need to be implemented by the mission developer.
-
-A template configuration folder was provided and can be copied into the project root to have
-a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
-information about the possible options.
-
-## Prerequisites
-
-The Embedded Template Library (etl) is a dependency of the FSFW which is automatically
-installed and provided by the build system unless the correction version was installed.
-The current recommended version can be found inside the fsfw `CMakeLists.txt` file or by using
-`ccmake` and looking up the `FSFW_ETL_LIB_MAJOR_VERSION` variable.
-
-You can install the ETL library like this. On Linux, it might be necessary to add `sudo` before
-the install call:
-
-```cpp
-git clone https://github.com/ETLCPP/etl
-cd etl
-git checkout <currentRecommendedVersion>
-mkdir build && cd build
-cmake ..
-cmake --install .
-```
-
-It is recommended to install `20.27.2` or newer for the package version handling of
-ETL to work.
-
-## Adding the library
-
-The following steps show how to add and use FSFW components. It is still recommended to
-try out the example mentioned above to get started, but the following steps show how to
-add and link against the FSFW library in general.
-
-1. Add this repository as a submodule
-
-   ```sh
-   git submodule add https://egit.irs.uni-stuttgart.de/fsfw/fsfw.git fsfw   
-   ```
-
-2. Add the following directive inside the uppermost `CMakeLists.txt` file of your project
-
-   ```cmake
-   add_subdirectory(fsfw)
-   ```
-
-3. Make sure to provide a configuration folder and supply the path to that folder with
-   the `FSFW_CONFIG_PATH` CMake variable from the uppermost `CMakeLists.txt` file.
-   It is also necessary to provide the `printChar` function. You can find an example
-   implementation for a hosted build 
-   [here](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted/src/branch/master/bsp_hosted/utility/printChar.c).
-
-4. Link against the FSFW library
-
-   ```sh
-   target_link_libraries(${YourProjectName} PRIVATE fsfw)
-   ```
-
-5. It should now be possible use the FSFW as a static library from the user code.
-
-## Building the unittests
-
-The FSFW also has unittests which use the [Catch2 library](https://github.com/catchorg/Catch2).
-These are built by setting the CMake option `FSFW_BUILD_UNITTESTS` to `ON` or `TRUE`
-from your project `CMakeLists.txt` file or from the command line.
-
-You can install the Catch2 library, which prevents the build system to avoid re-downloading
-the dependency if the unit tests are completely rebuilt. The current recommended version
-can be found inside the fsfw `CMakeLists.txt` file or by using `ccmake` and looking up
-the `FSFW_CATCH2_LIB_VERSION` variable.
-
-```sh
-git clone https://github.com/catchorg/Catch2.git
-cd Catch2
-git checkout <currentRecommendedVersion>
-cmake -Bbuild -H. -DBUILD_TESTING=OFF
-sudo cmake --build build/ --target install
-```
-
-The fsfw-tests binary will be built as part of the static library and dropped alongside it.
-If the unittests are built, the library and the tests will be built with coverage information by
-default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
-
-You can use the following commands inside the `fsfw` folder to set up the build system
-
-```sh
-mkdir build-tests && cd build-tests
-cmake -DFSFW_BUILD_TESTS=ON -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
-```
-
-You can also use `-DFSFW_OSAL=linux` on Linux systems.
-
-Coverage data in HTML format can be generated using the `CodeCoverage`
-[CMake module](https://github.com/bilke/cmake-modules/tree/master).
-To build the unittests, run them and then generate the coverage data in this format,
-the following command can be used inside the build directory after the build system was set up
-
-```sh
-cmake --build . -- fsfw-tests_coverage -j
-```
-
-The `coverage.py` script located in the `script` folder can also be used to do this conveniently.
-
-## Building the documentations
-
-The FSFW documentation is built using the tools Sphinx, doxygen and breathe based on the
-instructions provided in  [this blogpost](https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/). If you
-want to do this locally, set up the prerequisites first. This requires a ``python3``
-installation as well. Example here is for Ubuntu.
-
-```sh
-sudo apt-get install doxygen graphviz
-```
-
-And the following Python packages
-
-```sh
-python3 -m pip install sphinx breathe
-```
-
-You can set up a documentation build system using the following commands
-
-```sh
-mkdir build-docs && cd build-docs
-cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
-```
-
-Then you can generate the documentation using
-
-```sh
-cmake --build . -- Sphinx -j
-```
-
-You can find the generated documentation inside the `docs/sphinx` folder inside the build
-folder. Simply open the `index.html` in the webbrowser of your choice.
-
-The `helper.py` script located in the script` folder can also be used to create, build
-and open the documentation conveniently. Try `helper.py -h for more information.
-
-## Formatting the sources
-
-The formatting is done by the `clang-format` tool. The configuration is contained within the
-`.clang-format` file in the repository root. As long as `clang-format` is installed, you
-can run the `auto-format.sh` helper script to format all source files consistently. Furthermore cmake-format is required to format CMake files which can be installed with:
-````sh
-sudo pip install cmakelang
-````
-
-## Index
-
-[1. High-level overview](docs/README-highlevel.md#top) <br>
-[2. Core components](docs/README-core.md#top) <br>
-[3. Configuration](docs/README-config.md#top) <br>
-[4. OSAL overview](docs/README-osal.md#top) <br>
-[5. PUS services](docs/README-pus.md#top) <br>
-[6. Device Handler overview](docs/README-devicehandlers.md#top) <br>
-[7. Controller overview](docs/README-controllers.md#top) <br>
-[8. Local Data Pools](docs/README-localpools.md#top) <br>
-
-
-
+-
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -97,7 +97,7 @@ pipeline {
                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
                    }
                }
-                dir(BUILDDIR_LINUX) {
+                dir(BUILDDIR) {
                    sshagent(credentials: ['documentation-buildfix']) {
                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
                    }
@ -116,7 +116,7 @@ pipeline {
                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
                    }
                }
-                dir(BUILDDIR_LINUX) {
+                dir(BUILDDIR) {
                    sshagent(credentials: ['documentation-buildfix']) {
                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
                    }
--- a/src/fsfw/action/ActionHelper.cpp
+++ b/src/fsfw/action/ActionHelper.cpp
@ -59,24 +59,17 @@ void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }

 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                    store_address_t dataAddress) {
-  bool hasAdditionalData = false;
  const uint8_t* dataPtr = nullptr;
  size_t size = 0;
-  ReturnValue_t result;
-  if (dataAddress != store_address_t::invalid()) {
-    hasAdditionalData = true;
-    ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-    if (result != returnvalue::OK) {
-      CommandMessage reply;
-      ActionMessage::setStepReply(&reply, actionId, 0, result);
-      queueToUse->sendMessage(commandedBy, &reply);
-      return;
-    }
+  ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
+  if (result != returnvalue::OK) {
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, result);
+    queueToUse->sendMessage(commandedBy, &reply);
+    return;
  }
  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-  if (hasAdditionalData) {
-    ipcStore->deleteData(dataAddress);
-  }
+  ipcStore->deleteData(dataAddress);
  if (result == HasActionsIF::EXECUTION_FINISHED) {
    CommandMessage reply;
    ActionMessage::setCompletionReply(&reply, actionId, true, result);
--- a/src/fsfw/action/CommandActionHelper.h
+++ b/src/fsfw/action/CommandActionHelper.h
@ -16,8 +16,8 @@ class CommandActionHelper {
 public:
  explicit CommandActionHelper(CommandsActionsIF* owner);
  virtual ~CommandActionHelper();
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
-                              const uint8_t* data = nullptr, uint32_t size = 0);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, const uint8_t* data,
+                              uint32_t size);
  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
  ReturnValue_t initialize();
  ReturnValue_t handleReply(CommandMessage* reply);
--- a/src/fsfw/cfdp/VarLenFields.h
+++ b/src/fsfw/cfdp/VarLenFields.h
@ -51,9 +51,8 @@ class VarLenField : public SerializeIF {
    return os;
  }
 #endif
+
 private:
-  using SerializeIF::deSerialize;  // we overloaded above, so this is needed to uncofuse the
-                                   // compiler
  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                            Endianness streamEndianness) override;

--- a/src/fsfw/cfdp/pdu/HeaderCreator.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderCreator.cpp
@ -24,8 +24,8 @@ ReturnValue_t HeaderCreator::serialize(uint8_t **buffer, size_t *size, size_t ma
  *buffer += 1;
  **buffer = pduDataFieldLen & 0x00ff;
  *buffer += 1;
-  **buffer = segmentationCtrl << 7 | ((pduConf.sourceId.getWidth() - 1) << 4) |
-             segmentMetadataFlag << 3 | (pduConf.seqNum.getWidth() - 1);
+  **buffer = segmentationCtrl << 7 | pduConf.sourceId.getWidth() << 4 | segmentMetadataFlag << 3 |
+             pduConf.seqNum.getWidth();
  *buffer += 1;
  *size += 4;
  ReturnValue_t result = pduConf.sourceId.serialize(buffer, size, maxSize, streamEndianness);
--- a/src/fsfw/cfdp/pdu/HeaderReader.cpp
+++ b/src/fsfw/cfdp/pdu/HeaderReader.cpp
@ -78,11 +78,11 @@ cfdp::SegmentationControl PduHeaderReader::getSegmentationControl() const {
 }

 cfdp::WidthInBytes PduHeaderReader::getLenEntityIds() const {
-  return static_cast<cfdp::WidthInBytes>(((pointers.fixedHeader->fourthByte >> 4) & 0b111) + 1);
+  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte >> 4) & 0x07);
 }

 cfdp::WidthInBytes PduHeaderReader::getLenSeqNum() const {
-  return static_cast<cfdp::WidthInBytes>((pointers.fixedHeader->fourthByte & 0b111) + 1);
+  return static_cast<cfdp::WidthInBytes>(pointers.fixedHeader->fourthByte & 0x07);
 }

 cfdp::SegmentMetadataFlag PduHeaderReader::getSegmentMetadataFlag() const {
--- a/src/fsfw/cfdp/tlv/EntityIdTlv.h
+++ b/src/fsfw/cfdp/tlv/EntityIdTlv.h
@ -23,8 +23,6 @@ class EntityIdTlv : public TlvIF {
   */
  ReturnValue_t deSerialize(cfdp::Tlv& tlv, Endianness endianness);

-  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
-                                   // the compiler
  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                            Endianness streamEndianness) override;

--- a/src/fsfw/cfdp/tlv/FilestoreResponseTlv.h
+++ b/src/fsfw/cfdp/tlv/FilestoreResponseTlv.h
@ -29,8 +29,6 @@ class FilestoreResponseTlv : public cfdp::FilestoreTlvBase {
   */
  ReturnValue_t deSerialize(const cfdp::Tlv& tlv, Endianness endianness);

-  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
-                                   // the compiler
  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
                            Endianness streamEndianness) override;

--- a/src/fsfw/container/FixedArrayList.h
+++ b/src/fsfw/container/FixedArrayList.h
@ -12,7 +12,6 @@ template <typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList : public ArrayList<T, count_t> {
  static_assert(MAX_SIZE <= std::numeric_limits<count_t>::max(),
                "count_t is not large enough to hold MAX_SIZE");
-  static_assert(MAX_SIZE > 0, "MAX_SIZE is 0");

 private:
  T data[MAX_SIZE];
--- a/src/fsfw/container/FixedMap.h
+++ b/src/fsfw/container/FixedMap.h
@ -155,8 +155,8 @@ class FixedMap : public SerializeIF {

  uint32_t maxSize() const { return theMap.maxSize(); }

-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override {
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                  Endianness streamEndianness) const {
    ReturnValue_t result =
        SerializeAdapter::serialize(&this->_size, buffer, size, maxSize, streamEndianness);
    uint32_t i = 0;
@ -170,7 +170,7 @@ class FixedMap : public SerializeIF {
    return result;
  }

-  size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const {
    uint32_t printSize = sizeof(_size);
    uint32_t i = 0;

@ -182,8 +182,8 @@ class FixedMap : public SerializeIF {
    return printSize;
  }

-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    Endianness streamEndianness) {
    ReturnValue_t result =
        SerializeAdapter::deSerialize(&this->_size, buffer, size, streamEndianness);
    if (this->_size > theMap.maxSize()) {
--- a/src/fsfw/datapool/PoolDataSetBase.h
+++ b/src/fsfw/datapool/PoolDataSetBase.h
@ -64,8 +64,8 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
   * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
   *      commit() in between
   */
-  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                     uint32_t lockTimeout = 20) override;
+  virtual ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                             uint32_t lockTimeout = 20) override;
  /**
   * @brief	The commit call initializes writing back the registered variables.
   * @details
@ -84,15 +84,15 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
   * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
   * 			  contains non write-only variables
   */
-  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                       uint32_t lockTimeout = 20) override;
+  virtual ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                               uint32_t lockTimeout = 20) override;

  /**
   * Register the passed pool variable instance into the data set.
   * @param variable
   * @return
   */
-  ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+  virtual ReturnValue_t registerVariable(PoolVariableIF* variable) override;

  /**
   * Provides the means to lock the underlying data structure to ensure
--- a/src/fsfw/datapoollocal/LocalPoolVariable.h
+++ b/src/fsfw/datapoollocal/LocalPoolVariable.h
@ -87,9 +87,9 @@ class LocalPoolVariable : public LocalPoolObjectBase {

  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          SerializeIF::Endianness streamEndianness) const override;
-  size_t getSerializedSize() const override;
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override;
+  virtual size_t getSerializedSize() const override;
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    SerializeIF::Endianness streamEndianness) override;

  /**
   * @brief	This is a call to read the array's values
--- a/src/fsfw/datapoollocal/LocalPoolVector.h
+++ b/src/fsfw/datapoollocal/LocalPoolVector.h
@ -98,11 +98,11 @@ class LocalPoolVector : public LocalPoolObjectBase {
  T& operator[](size_t i);
  const T& operator[](size_t i) const;

-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
-                          SerializeIF::Endianness streamEndiannes) const override;
-  size_t getSerializedSize() const override;
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override;
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
+                                  SerializeIF::Endianness streamEndiannes) const override;
+  virtual size_t getSerializedSize() const override;
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    SerializeIF::Endianness streamEndianness) override;

  /**
   * @brief	This is a call to read the array's values
--- a/src/fsfw/events/EventManager.cpp
+++ b/src/fsfw/events/EventManager.cpp
@ -15,12 +15,11 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
    {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS, sizeof(EventIdRangeMatcher)},
    {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS, sizeof(ReporterRangeMatcher)}};

-EventManager::EventManager(object_id_t setObjectId, uint32_t eventQueueDepth)
+EventManager::EventManager(object_id_t setObjectId)
    : SystemObject(setObjectId), factoryBackend(0, poolConfig, false, true) {
  mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  eventReportQueue = QueueFactory::instance()->createMessageQueue(
-      eventQueueDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
 }

 EventManager::~EventManager() {
@ -48,20 +47,9 @@ ReturnValue_t EventManager::performOperation(uint8_t opCode) {

 void EventManager::notifyListeners(EventMessage* message) {
  lockMutex();
-  for (auto& listener : listenerList) {
-    if (listener.second.match(message)) {
-      ReturnValue_t result =
-          MessageQueueSenderIF::sendMessage(listener.first, message, message->getSender());
-      if (result != returnvalue::OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << std::hex << "EventManager::notifyListeners: MSG to 0x" << std::setfill('0')
-                   << std::setw(8) << listener.first << " failed with result 0x" << std::setw(4)
-                   << result << std::setfill(' ') << std::endl;
-#else
-        sif::printError("Sending message to listener 0x%08x failed with result %04x\n",
-                        listener.first, result);
-#endif
-      }
+  for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
+    if (iter->second.match(message)) {
+      MessageQueueSenderIF::sendMessage(iter->first, message, message->getSender());
    }
  }
  unlockMutex();
@ -212,19 +200,4 @@ void EventManager::printUtility(sif::OutputTypes printType, EventMessage* messag
  }
 }

-void EventManager::printListeners() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Event manager listener MQ IDs:" << std::setfill('0') << std::hex << std::endl;
-  for (auto& listener : listenerList) {
-    sif::info << "0x" << std::setw(8) << listener.first << std::endl;
-  }
-  sif::info << std::dec << std::setfill(' ');
-#else
-  sif::printInfo("Event manager listener MQ IDs:\n");
-  for (auto& listener : listenerList) {
-    sif::printInfo("0x%08x\n", listener.first);
-  }
-#endif
-}
-
 #endif /* FSFW_OBJ_EVENT_TRANSLATION == 1 */
--- a/src/fsfw/events/EventManager.h
+++ b/src/fsfw/events/EventManager.h
@ -21,7 +21,9 @@ extern const char* translateEvents(Event event);

 class EventManager : public EventManagerIF, public ExecutableObjectIF, public SystemObject {
 public:
-  EventManager(object_id_t setObjectId, uint32_t eventQueueDepth);
+  static const uint16_t MAX_EVENTS_PER_CYCLE = 80;
+
+  EventManager(object_id_t setObjectId);
  virtual ~EventManager();

  void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
@ -42,7 +44,6 @@ class EventManager : public EventManagerIF, public ExecutableObjectIF, public Sy
                                          object_id_t reporterFrom = 0, object_id_t reporterTo = 0,
                                          bool reporterInverted = false);
  ReturnValue_t performOperation(uint8_t opCode);
-  void printListeners();

 protected:
  MessageQueueIF* eventReportQueue = nullptr;
--- a/src/fsfw/events/fwSubsystemIdRanges.h
+++ b/src/fsfw/events/fwSubsystemIdRanges.h
@ -10,7 +10,7 @@ enum : uint8_t {
  CDH = 28,
  TCS_1 = 59,
  PCDU_1 = 42,
-  POWER_SWITCH_IF = 43,
+  PCDU_2 = 43,
  HEATER = 50,
  T_SENSORS = 52,
  FDIR = 70,
@ -33,7 +33,6 @@ enum : uint8_t {
  PUS_SERVICE_23 = 103,
  MGM_LIS3MDL = 106,
  MGM_RM3100 = 107,
-  CFDP = 108,

  FW_SUBSYSTEM_ID_RANGE
 };
--- a/src/fsfw/globalfunctions/Type.h
+++ b/src/fsfw/globalfunctions/Type.h
@ -44,13 +44,13 @@ class Type : public SerializeIF {

  static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);

-  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                          Endianness streamEndianness) const override;
+  virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                  Endianness streamEndianness) const override;

-  size_t getSerializedSize() const override;
+  virtual size_t getSerializedSize() const override;

-  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                            Endianness streamEndianness) override;
+  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                                    Endianness streamEndianness) override;

 private:
  ActualType_t actualType;
--- a/src/fsfw/housekeeping/HousekeepingSnapshot.h
+++ b/src/fsfw/housekeeping/HousekeepingSnapshot.h
@ -54,8 +54,8 @@ class HousekeepingSnapshot : public SerializeIF {
  HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize, LocalPoolObjectBase* dataSetPtr)
      : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr){};

-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const {
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                  Endianness streamEndianness) const {
    if (timeStamp != nullptr) {
      /* Endianness will always be MACHINE, so we can simply use memcpy
      here. */
@ -70,15 +70,15 @@ class HousekeepingSnapshot : public SerializeIF {
    return updateData->serialize(buffer, size, maxSize, streamEndianness);
  }

-  size_t getSerializedSize() const {
+  virtual size_t getSerializedSize() const {
    if (updateData == nullptr) {
      return 0;
    }
    return timeStampSize + updateData->getSerializedSize();
  }

-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    SerializeIF::Endianness streamEndianness) override {
    if (*size < timeStampSize) {
      return SerializeIF::STREAM_TOO_SHORT;
    }
--- a/src/fsfw/monitoring/AbsLimitMonitor.h
+++ b/src/fsfw/monitoring/AbsLimitMonitor.h
@ -32,9 +32,9 @@ class AbsLimitMonitor : public MonitorBase<T> {
    return returnvalue::OK;  // We're not out of range.
  }

-  ReturnValue_t getParameter(uint8_t domainId, uint8_t parameterId,
-                             ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
-                             uint16_t startAtIndex) override {
+  virtual ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
+                                     ParameterWrapper *parameterWrapper,
+                                     const ParameterWrapper *newValues, uint16_t startAtIndex) {
    ReturnValue_t result = this->MonitorBase<T>::getParameter(
        domainId, parameterId, parameterWrapper, newValues, startAtIndex);
    // We'll reuse the DOMAIN_ID of MonitorReporter,
--- a/src/fsfw/monitoring/MonitoringMessage.h
+++ b/src/fsfw/monitoring/MonitoringMessage.h
@ -13,7 +13,6 @@ class MonitoringMessage : public CommandMessage {
  static const Command_t LIMIT_VIOLATION_REPORT = MAKE_COMMAND_ID(10);
  virtual ~MonitoringMessage();
  static void setLimitViolationReport(CommandMessage* message, store_address_t storeId);
-  using CommandMessage::clear;
  static void clear(CommandMessage* message);
  static store_address_t getStoreId(const CommandMessage* message);
  static void setTypicalMessage(CommandMessage* message, Command_t type, store_address_t storeId);
--- a/src/fsfw/osal/common/TcpIpBase.cpp
+++ b/src/fsfw/osal/common/TcpIpBase.cpp
@ -40,8 +40,6 @@ int TcpIpBase::closeSocket(socket_t socket) {
  return closesocket(socket);
 #elif defined(PLATFORM_UNIX)
  return close(socket);
-#else
-  return -1;
 #endif
 }

@ -50,7 +48,5 @@ int TcpIpBase::getLastSocketError() {
  return WSAGetLastError();
 #elif defined(PLATFORM_UNIX)
  return errno;
-#else
-  return 0;
 #endif
 }
--- a/src/fsfw/osal/common/TcpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/TcpTmTcBridge.cpp
@ -16,9 +16,9 @@

 #endif

-TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
-    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
+                             object_id_t tcStoreId)
+    : TmTcBridge("TCP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
  mutex = MutexFactory::instance()->createMutex();
  // Connection is always up, TM is requested by connecting to server and receiving packets
  registerCommConnect();
--- a/src/fsfw/osal/common/TcpTmTcBridge.h
+++ b/src/fsfw/osal/common/TcpTmTcBridge.h
@ -38,7 +38,7 @@ class TcpTmTcBridge : public TmTcBridge {
   * @param tmStoreId TM store object ID. It is recommended to the default object ID
   * @param tcStoreId TC store object ID. It is recommended to the default object ID
   */
-  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, uint32_t msgQueueDepth,
+  TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                object_id_t tmStoreId = objects::TM_STORE,
                object_id_t tcStoreId = objects::TC_STORE);
  virtual ~TcpTmTcBridge();
--- a/src/fsfw/osal/common/UdpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/UdpTmTcBridge.cpp
@ -20,9 +20,9 @@
 const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;

 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
-                             uint32_t msgQueueDepth, const std::string &udpServerPort_,
-                             object_id_t tmStoreId, object_id_t tcStoreId)
-    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, msgQueueDepth, tmStoreId, tcStoreId) {
+                             const std::string &udpServerPort_, object_id_t tmStoreId,
+                             object_id_t tcStoreId)
+    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
  if (udpServerPort_.empty()) {
    udpServerPort = DEFAULT_SERVER_PORT;
  } else {
@ -126,7 +126,10 @@ ReturnValue_t UdpTmTcBridge::sendTm(const uint8_t *data, size_t dataLen) {
    tcpip::handleError(tcpip::Protocol::UDP, tcpip::ErrorSources::SENDTO_CALL);
  }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && FSFW_UDP_SEND_WIRETAPPING_ENABLED == 1
-  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent << " bytes were sent" << std::endl;
+  sif::debug << "TmTcUdpBridge::sendTm: " << bytesSent
+             << " bytes were"
+                " sent."
+             << std::endl;
 #endif
  return returnvalue::OK;
 }
--- a/src/fsfw/osal/common/UdpTmTcBridge.h
+++ b/src/fsfw/osal/common/UdpTmTcBridge.h
@ -29,7 +29,7 @@ class UdpTmTcBridge : public TmTcBridge, public TcpIpBase {
  /* The ports chosen here should not be used by any other process. */
  static const std::string DEFAULT_SERVER_PORT;

-  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination, uint32_t msgQueueDepth,
+  UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                const std::string& udpServerPort = "", object_id_t tmStoreId = objects::TM_STORE,
                object_id_t tcStoreId = objects::TC_STORE);
  ~UdpTmTcBridge() override;
--- a/src/fsfw/osal/host/FixedTimeslotTask.h
+++ b/src/fsfw/osal/host/FixedTimeslotTask.h
@ -5,7 +5,6 @@
 #include <condition_variable>
 #include <thread>
 #include <vector>
-#include <string>

 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/tasks/FixedSlotSequence.h"
--- a/src/fsfw/osal/host/PeriodicTask.h
+++ b/src/fsfw/osal/host/PeriodicTask.h
@ -5,7 +5,6 @@
 #include <condition_variable>
 #include <thread>
 #include <vector>
-#include <string>

 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/tasks/PeriodicTaskBase.h"
--- a/src/fsfw/osal/host/taskHelpers.h
+++ b/src/fsfw/osal/host/taskHelpers.h
@ -4,7 +4,6 @@
 #include <fsfw/returnvalues/returnvalue.h>

 #include <thread>
-#include <string>

 namespace tasks {

--- a/src/fsfw/osal/linux/Clock.cpp
+++ b/src/fsfw/osal/linux/Clock.cpp
@ -76,17 +76,14 @@ timeval Clock::getUptime() {
 }

 ReturnValue_t Clock::getUptime(timeval* uptime) {
+  // TODO This is not posix compatible and delivers only seconds precision
+  //  Linux specific file read but more precise.
  double uptimeSeconds;
-  std::ifstream ifile("/proc/uptime");
-  if (ifile.bad()) {
-    return returnvalue::FAILED;
-  }
-  if (ifile >> uptimeSeconds) {
+  if (std::ifstream("/proc/uptime", std::ios::in) >> uptimeSeconds) {
    uptime->tv_sec = uptimeSeconds;
    uptime->tv_usec = uptimeSeconds * (double)1e6 - (uptime->tv_sec * 1e6);
-    return returnvalue::OK;
  }
-  return returnvalue::FAILED;
+  return returnvalue::OK;
 }

 // Wait for new FSFW Clock function delivering seconds uptime.
--- a/src/fsfw/osal/rtems/CpuUsage.h
+++ b/src/fsfw/osal/rtems/CpuUsage.h
@ -19,13 +19,13 @@ class CpuUsage : public SerializeIF {
    float timeRunning;
    float percentUsage;

-    ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                            Endianness streamEndianness) const override;
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                    Endianness streamEndianness) const override;

-    size_t getSerializedSize() const override;
+    virtual size_t getSerializedSize() const override;

-    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                              Endianness streamEndianness) override;
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                      Endianness streamEndianness) override;
  };

  CpuUsage();
--- a/src/fsfw/parameters/ParameterWrapper.h
+++ b/src/fsfw/parameters/ParameterWrapper.h
@ -40,15 +40,13 @@ class ParameterWrapper : public SerializeIF {
  ParameterWrapper(Type type, uint8_t rows, uint8_t columns, const void *data);
  virtual ~ParameterWrapper();

-  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                          Endianness streamEndianness) const override;
+  virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                  Endianness streamEndianness) const override;

-  size_t getSerializedSize() const override;
+  virtual size_t getSerializedSize() const override;

-  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
-                                   // the compiler
-  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                            Endianness streamEndianness) override;
+  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                                    Endianness streamEndianness) override;

  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                                    Endianness streamEndianness, uint16_t startWritingAtIndex = 0);
--- a/src/fsfw/power/Fuse.h
+++ b/src/fsfw/power/Fuse.h
@ -32,7 +32,7 @@ class Fuse : public SystemObject,
    gp_id_t poolIdPower;
  };

-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
  //! PSS detected that current on a fuse is totally out of bounds.
  static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, severity::LOW);
  //! PSS detected a fuse that went off.
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@ -28,12 +28,10 @@ class PowerSwitchIF {
  static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
  static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
  static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
-  static const ReturnValue_t SWITCH_UNKNOWN = MAKE_RETURN_CODE(5);
-
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
-  //!< Someone detected that a switch went off which shouldn't. Severity:
-  //!< Low, Parameter1: switchId1, Parameter2: switchId2
-  static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, severity::LOW);
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
+  static const Event SWITCH_WENT_OFF = MAKE_EVENT(
+      0, severity::LOW);  //!< Someone detected that a switch went off which shouldn't. Severity:
+                          //!< Low, Parameter1: switchId1, Parameter2: switchId2
  /**
   * send a direct command to the Power Unit to enable/disable the specified switch.
   *
@ -52,7 +50,6 @@ class PowerSwitchIF {
   * @return
   *     - @c SWITCH_ON if the specified switch is on.
   *     - @c SWITCH_OFF if the specified switch is off.
-   *     - @c SWITCH_UNKNOWN if the state of the specified switch is unknown.
   *     - @c returnvalue::FAILED if an error occured
   */
  virtual ReturnValue_t getSwitchState(power::Switch_t switchNr) const = 0;
--- a/src/fsfw/pus/CServiceHealthCommanding.cpp
+++ b/src/fsfw/pus/CServiceHealthCommanding.cpp
@ -82,9 +82,6 @@ ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message,
  ReturnValue_t result = returnvalue::OK;
  switch (subservice) {
    case (Subservice::COMMAND_SET_HEALTH): {
-      if (tcDataLen != sizeof(object_id_t) + sizeof(HasHealthIF::HealthState)) {
-        return CommandingServiceBase::INVALID_TC;
-      }
      HealthSetCommand healthCommand;
      result = healthCommand.deSerialize(&tcData, &tcDataLen, SerializeIF::Endianness::BIG);
      if (result != returnvalue::OK) {
@ -96,7 +93,7 @@ ReturnValue_t CServiceHealthCommanding::prepareCommand(CommandMessage *message,
    }
    case (Subservice::COMMAND_ANNOUNCE_HEALTH): {
      HealthMessage::setHealthMessage(message, HealthMessage::HEALTH_ANNOUNCE);
-      return CommandingServiceBase::EXECUTION_COMPLETE;
+      break;
    }
    case (Subservice::COMMAND_ANNOUNCE_HEALTH_ALL): {
      ReturnValue_t result = iterateHealthTable(true);
--- a/src/fsfw/pus/servicepackets/Service5Packets.h
+++ b/src/fsfw/pus/servicepackets/Service5Packets.h
@ -24,8 +24,8 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
        parameter1(parameter1_),
        parameter2(parameter2_) {}

-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          SerializeIF::Endianness streamEndianness) const override {
+  virtual 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);
    if (result != returnvalue::OK) {
@ -46,7 +46,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
    return result;
  }

-  size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const override {
    uint32_t size = 0;
    size += SerializeAdapter::getSerializedSize(&reportId);
    size += SerializeAdapter::getSerializedSize(&objectId);
@ -55,8 +55,8 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
    return size;
  }

-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    SerializeIF::Endianness streamEndianness) override {
    return returnvalue::FAILED;
  }

--- a/src/fsfw/serialize/SerialArrayListAdapter.h
+++ b/src/fsfw/serialize/SerialArrayListAdapter.h
@ -16,10 +16,8 @@ class SerialArrayListAdapter : public SerializeIF {
 public:
  SerialArrayListAdapter(ArrayList<T, count_t>* adaptee) : adaptee(adaptee) {}

-  using SerializeIF::serialize;  // we overload this function as well, so this is needed to uncofuse
-                                 // the compiler
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override {
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                  Endianness streamEndianness) const {
    return serialize(adaptee, buffer, size, maxSize, streamEndianness);
  }

@ -36,7 +34,7 @@ class SerialArrayListAdapter : public SerializeIF {
    return result;
  }

-  size_t getSerializedSize() const override { return getSerializedSize(adaptee); }
+  virtual size_t getSerializedSize() const { return getSerializedSize(adaptee); }

  static uint32_t getSerializedSize(const ArrayList<T, count_t>* list) {
    uint32_t printSize = sizeof(count_t);
@ -49,10 +47,8 @@ class SerialArrayListAdapter : public SerializeIF {
    return printSize;
  }

-  using SerializeIF::deSerialize;  // we overload this function as well, so this is needed to
-                                   // uncofuse the compiler
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    Endianness streamEndianness) {
    return deSerialize(adaptee, buffer, size, streamEndianness);
  }

--- a/src/fsfw/serialize/SerialLinkedListAdapter.h
+++ b/src/fsfw/serialize/SerialLinkedListAdapter.h
@ -45,10 +45,8 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
  SerialLinkedListAdapter(bool printCount = false)
      : SinglyLinkedList<T>(), printCount(printCount) {}

-  using SerializeIF::serialize;  // we overloaded this function, so this is needed to unconfuse the
-                                 // compiler
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override {
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                  Endianness streamEndianness) const override {
    if (printCount) {
      count_t mySize = SinglyLinkedList<T>::getSize();
      ReturnValue_t result =
@ -70,7 +68,7 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
    return result;
  }

-  size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const override {
    if (printCount) {
      return SerialLinkedListAdapter<T>::getSerializedSize() + sizeof(count_t);
    } else {
@ -78,8 +76,6 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
    }
  }

-  using SerializeIF::deSerialize;  // we overloaded this function, so this is needed to unconfuse
-                                   // the compiler
  static size_t getSerializedSize(const LinkedElement<T>* element) {
    size_t size = 0;
    while (element != nullptr) {
@ -89,8 +85,8 @@ class SerialLinkedListAdapter : public SinglyLinkedList<T>, public SerializeIF {
    return size;
  }

-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    Endianness streamEndianness) override {
    return deSerialize(SinglyLinkedList<T>::start, buffer, size, streamEndianness);
  }

--- a/src/fsfw/serialize/SerializeElement.h
+++ b/src/fsfw/serialize/SerializeElement.h
@ -32,8 +32,8 @@ class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {

  size_t getSerializedSize() const override { return SerializeAdapter::getSerializedSize(&entry); }

-  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-                            Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                                    Endianness streamEndianness) override {
    return SerializeAdapter::deSerialize(&entry, buffer, size, streamEndianness);
  }

--- a/src/fsfw/subsystem/modes/ModeDefinitions.h
+++ b/src/fsfw/subsystem/modes/ModeDefinitions.h
@ -15,8 +15,8 @@ class ModeListEntry : public SerializeIF, public LinkedElement<ModeListEntry> {
  uint8_t value3 = 0;
  uint8_t value4 = 0;

-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override {
+  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                  Endianness streamEndianness) const {
    ReturnValue_t result;

    result = SerializeAdapter::serialize(&value1, buffer, size, maxSize, streamEndianness);
@ -40,12 +40,12 @@ class ModeListEntry : public SerializeIF, public LinkedElement<ModeListEntry> {
    return result;
  }

-  size_t getSerializedSize() const override {
+  virtual size_t getSerializedSize() const {
    return sizeof(value1) + sizeof(value2) + sizeof(value3) + sizeof(value4);
  }

-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override {
+  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                                    Endianness streamEndianness) {
    ReturnValue_t result;

    result = SerializeAdapter::deSerialize(&value1, buffer, size, streamEndianness);
--- a/src/fsfw/tmtcpacket/pus/tm/PusTmCreator.h
+++ b/src/fsfw/tmtcpacket/pus/tm/PusTmCreator.h
@ -40,7 +40,7 @@ struct PusTmParams {
              size_t dataLen)
      : secHeader(service, subservice, timeStamper), adapter(data, dataLen), sourceData(&adapter) {}
  PusTmSecHeader secHeader;
-  SerialBufferAdapter<size_t> adapter;
+  SerialBufferAdapter<uint8_t> adapter;
  const SerializeIF* sourceData = nullptr;
 };

--- a/src/fsfw/tmtcservices/TmTcBridge.cpp
+++ b/src/fsfw/tmtcservices/TmTcBridge.cpp
@ -8,7 +8,7 @@
 #define TMTCBRIDGE_WIRETAPPING 0

 TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDestination,
-                       uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId)
+                       object_id_t tmStoreId, object_id_t tcStoreId)
    : SystemObject(objectId),
      name(name),
      tmStoreId(tmStoreId),
@ -18,7 +18,7 @@ TmTcBridge::TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDes
 {
  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
  tmTcReceptionQueue = QueueFactory::instance()->createMessageQueue(
-      msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      TMTC_RECEPTION_QUEUE_DEPTH, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }

 TmTcBridge::~TmTcBridge() { QueueFactory::instance()->deleteMessageQueue(tmTcReceptionQueue); }
--- a/src/fsfw/tmtcservices/TmTcBridge.h
+++ b/src/fsfw/tmtcservices/TmTcBridge.h
@ -15,6 +15,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
                   public ExecutableObjectIF,
                   public SystemObject {
 public:
+  static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
  static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
  static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 500;

@ -22,7 +23,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
  static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;

  TmTcBridge(const char* name, object_id_t objectId, object_id_t tcDestination,
-             uint32_t msgQueueDepth, object_id_t tmStoreId, object_id_t tcStoreId);
+             object_id_t tmStoreId, object_id_t tcStoreId);
  ~TmTcBridge() override;

  /**
--- a/src/fsfw/version.cpp
+++ b/src/fsfw/version.cpp
@ -1,7 +1,6 @@
 #include "version.h"

 #include <cstdio>
-#include <cstring>

 #include "fsfw/FSFWVersion.h"

@ -21,7 +20,7 @@ fsfw::Version::Version(int major, int minor, int revision, const char* addInfo)

 void fsfw::Version::getVersion(char* str, size_t maxLen) const {
  size_t len = snprintf(str, maxLen, "%d.%d.%d", major, minor, revision);
-  if (addInfo != nullptr and std::strcmp(addInfo, "") != 0) {
+  if (addInfo != nullptr) {
    snprintf(str + len, maxLen - len, "-%s", addInfo);
  }
 }
@ -31,7 +30,7 @@ namespace fsfw {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 std::ostream& operator<<(std::ostream& os, const Version& v) {
  os << v.major << "." << v.minor << "." << v.revision;
-  if (v.addInfo != nullptr and std::strcmp(v.addInfo, "") != 0) {
+  if (v.addInfo != nullptr) {
    os << "-" << v.addInfo;
  }
  return os;
--- a/unittests/CatchFactory.cpp
+++ b/unittests/CatchFactory.cpp
@ -30,7 +30,7 @@
 */
 void Factory::produceFrameworkObjects(void* args) {
  setStaticFrameworkObjectIds();
-  new EventManager(objects::EVENT_MANAGER, 80);
+  new EventManager(objects::EVENT_MANAGER);
  new HealthTable(objects::HEALTH_TABLE);
  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);

--- a/unittests/action/TestActionHelper.cpp
+++ b/unittests/action/TestActionHelper.cpp
@ -27,7 +27,12 @@ TEST_CASE("Action Helper", "[action]") {
    CHECK(not testDhMock.executeActionCalled);
    REQUIRE(actionHelper.handleActionMessage(&actionMessage) == returnvalue::OK);
    CHECK(testDhMock.executeActionCalled);
+    // No message is sent if everything is alright.
    CHECK(not testMqMock.wasMessageSent());
+    store_address_t invalidAddress;
+    ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+    actionHelper.handleActionMessage(&actionMessage);
+    CHECK(testMqMock.wasMessageSent());
    const uint8_t* ptr = nullptr;
    size_t size = 0;
    REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) ==
@ -39,10 +44,6 @@ TEST_CASE("Action Helper", "[action]") {
    for (uint8_t i = 0; i < 3; i++) {
      REQUIRE(ptr[i] == (i + 1));
    }
-    // Action message without application data is also valid
-    store_address_t invalidAddress;
-    ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
-    actionHelper.handleActionMessage(&actionMessage);
    testDhMock.clearBuffer();
  }

@ -94,5 +95,17 @@ TEST_CASE("Action Helper", "[action]") {
    REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
  }

+  SECTION("Missing IPC Data") {
+    ActionMessage::setCommand(&actionMessage, testActionId, store_address_t::invalid());
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(actionHelper.handleActionMessage(&actionMessage) == returnvalue::OK);
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.getNextSentMessage(testMessage) == returnvalue::OK);
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+    REQUIRE(ActionMessage::getReturnCode(&testMessage) ==
+            static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+    REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+  }
+
  SECTION("Data Reply") {}
 }
--- a/unittests/cfdp/pdu/testCfdpHeader.cpp
+++ b/unittests/cfdp/pdu/testCfdpHeader.cpp
@ -97,7 +97,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
      REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
                                SerializeIF::Endianness::BIG) == returnvalue::OK);
      CHECK(serBuf[0] == 0x3f);
-      CHECK(serBuf[3] == 0x88);
+      CHECK(serBuf[3] == 0x99);
      REQUIRE(creator.getCrcFlag() == true);
      REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
      REQUIRE(creator.getLargeFileFlag() == true);
@ -127,7 +127,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
      REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionMode::UNACKNOWLEDGED);
      REQUIRE(creator.getSegmentationControl() == true);
      // Last three bits are 2 now (length of seq number) and bit 1 to bit 3 is 4 (len entity IDs)
-      REQUIRE(serBuf[3] == 0b10111001);
+      REQUIRE(serBuf[3] == 0b11001010);
      uint32_t entityId = 0;
      size_t deSerSize = 0;
      SerializeAdapter::deSerialize(&entityId, serBuf.data() + 4, &deSerSize,
@ -175,7 +175,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
    REQUIRE(serBuf[1] == 0);
    REQUIRE(serBuf[2] == 0);
    // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00000000);
+    REQUIRE(serBuf[3] == 0b00010001);
    // Source ID
    REQUIRE(serBuf[4] == 0);
    // Transaction Seq Number
@ -220,7 +220,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
    REQUIRE(serBuf[1] == 0);
    REQUIRE(serBuf[2] == 0);
    // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00000000);
+    REQUIRE(serBuf[3] == 0b00010001);
    REQUIRE(serSize == 7);
    // Deser call not strictly necessary
    auto reader = PduHeaderReader(serBuf.data(), serBuf.size());
@ -270,7 +270,7 @@ TEST_CASE("CFDP Header", "[cfdp]") {
    REQUIRE(reader.parseData() == returnvalue::OK);
    // Everything except version bit flipped to one now
    REQUIRE(serBuf[0] == 0x3f);
-    REQUIRE(serBuf[3] == 0b10111001);
+    REQUIRE(serBuf[3] == 0b11001010);
    REQUIRE(reader.getWholePduSize() == 14);

    REQUIRE(reader.getCrcFlag() == true);
--- a/unittests/cfdp/pdu/testFileData.cpp
+++ b/unittests/cfdp/pdu/testFileData.cpp
@ -68,7 +68,7 @@ TEST_CASE("File Data PDU", "[cfdp][pdu]") {
    // Bits 1 to 3 length of enitity IDs is 2
    // Bit 4: Segment metadata flag is set
    // Bit 5 to seven: length of transaction seq num is 2
-    REQUIRE(fileDataBuffer[3] == 0b10011001);
+    REQUIRE(fileDataBuffer[3] == 0b10101010);
    REQUIRE((fileDataBuffer[10] >> 6) &
            0b11 == cfdp::RecordContinuationState::CONTAINS_START_AND_END);
    // Segment metadata length
--- a/unittests/cfdp/pdu/testFileDirective.cpp
+++ b/unittests/cfdp/pdu/testFileDirective.cpp
@ -30,7 +30,7 @@ TEST_CASE("CFDP File Directive", "[cfdp][pdu]") {
    REQUIRE(serBuf[1] == 0);
    REQUIRE(serBuf[2] == 5);
    // Entity and Transaction Sequence number are 1 byte large
-    REQUIRE(serBuf[3] == 0b00000000);
+    REQUIRE(serBuf[3] == 0b00010001);
    // Source ID
    REQUIRE(serBuf[4] == 0);
    // Transaction Seq Number
@ -82,4 +82,4 @@ TEST_CASE("CFDP File Directive", "[cfdp][pdu]") {
    // Invalid file directive
    REQUIRE(fdDeser.parseData() == cfdp::INVALID_DIRECTIVE_FIELD);
  }
-}
+}
--- a/unittests/cfdp/testCfdp.cpp
+++ b/unittests/cfdp/testCfdp.cpp
@ -33,8 +33,8 @@ TEST_CASE("CFDP Base", "[cfdp]") {
    // PDU data field length is 5 (4 + Directive code octet)
    REQUIRE(serBuf[1] == 0);
    REQUIRE(serBuf[2] == 5);
-    // Entity and Transaction Sequence number are 1 byte large, value minus one is stored
-    REQUIRE(serBuf[3] == 0b00000000);
+    // Entity and Transaction Sequence number are 1 byte large
+    REQUIRE(serBuf[3] == 0b00010001);
    // Source ID
    REQUIRE(serBuf[4] == 0);
    // Transaction Seq Number
Author	SHA1	Message	Date
Ulrich Mohr	73837856de	Do not read me	2023-09-05 12:54:16 +02:00
Ulrich Mohr	e73b9ff72c	Merge pull request 'v6.0.0' (#729 ) from development into master Reviewed-on: fsfw/fsfw#729	2023-02-23 13:42:48 +01:00