afmt

minimal first version
defaultconfig did not build anymore
2022-10-28 10:16:59 +02:00 · 2022-10-26 13:22:16 +02:00 · 2022-10-25 11:28:13 +02:00 · 2022-10-24 17:10:03 +02:00 · 2022-10-24 14:57:38 +02:00 · 2022-10-24 14:35:01 +02:00
161 changed files with 962 additions and 2229 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -10,21 +10,29 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 # [v6.0.0]

+## Fixes
+
+- I2C Bugfixes: Do not keep iterator as member and fix some incorrect handling with the iterator.
+  Also properly reset the reply size for successfull transfers and erroneous transfers.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/700
+- Bugfix for Serial Buffer Stream: Setting `doActive` to false now
+  actually fully disables printing.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/680
+- `TcpTmTcServer.cpp`: The server was actually not able to handle
+  CCSDS packets which were clumped together. This has been fixed now.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/673
+
 ## Added

- DHB TM handler `handleDeviceTM` renamed to `handleDeviceTm` and now takes
-  `util::DataWrapper` as the data input argument. This allows more flexibility in the possible
-  types of telemetry.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/669
- Add `util::DataWrapper` class inside the `util` module. This is a tagged union which allows
-  to specify raw data either as a classic C-style raw pointer and size or as a `SerializeIF`
-  pointer.
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/668
 - Add new `UnsignedByteField` class
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/660

 ## Changes

+- Remove default secondary header argument for
+  `uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)` and
+  `uint16_t getTmSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag)`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/689
 - Removed `HasReturnvaluesIF` class in favor of `returnvalue` namespace with `OK` and `FAILED`
  constants.
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/659
@ -32,6 +40,27 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  for other modules
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/655
  which also includes a migration guide
+- Bump Catch2 dependency to regular version `v3.1.0`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/678
+- `SerialBufferAdapter`: Rename `setBuffer` to `setConstBuffer` and update
+  API to expect `const uint8_t*` accordingly.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/677
+- Remove the following user includes from `fsfw/events/Event.h` and
+  `fsfw/returnvalues/returnvalue.h`:
+  - `#include "events/subsystemIdRanges.h"`
+  - `#include "returnvalues/classIds.h"`
+  The user has to include those themselves now
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/675
+- `DeviceHandlerBase`: Set command sender before calling `buildCommandFromCommand`.
+  This allows finishing action commands immediately inside the function.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/672
+- `DeviceHandlerBase`: New signature of `handleDeviceTm` which expects
+  a `const SerializeIF&` and additional helper variant which expects `const uint8_t*`
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/671
+- Improvements for `AcceptsTelemetryIF` and `AcceptsTelecommandsIF`:
+  - Make functions `const` where it makes sense
+  - Add `const char* getName const` abstract function
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/684

 # [v5.0.0] 25.07.2022

@ -166,6 +195,7 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
    - 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
+- Linux HAL: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1
 - 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
@ -180,17 +210,6 @@ https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/593
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/590
 - `Subsystem`: New API to add table and sequence entries

-## HAL
-
- SPI: Cache the SPI device in the communication interface. Architecturally, this makes a
-  lot more sense because each ComIF should be responsible for one SPI bus.
- SPI: Move the empty transfer to update the line polarity to separate function. This means
-  it is not automatically called when calling the setter function for SPI speed and mode.
-  The user should call this function after locking the CS mutex if multiple SPI devices with
-  differing speeds and modes are attached to one bus.
- SPI: Getter functions for SPI speed and mode.
- I2C: Add wiretapping option for I2C. Enabled with `FSFW_HAL_I2C_WIRETAPPING` defined to 1.
-
 ## Fixed

 - TCP TMTC Server: `MutexGuard` was not created properly in
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -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}.0.0-preview5
+    v${FSFW_CATCH2_LIB_MAJOR_VERSION}.1.0
    CACHE STRING "Catch2 library exact version requirement")

 # Keep this off by default for now. See PR:
@ -195,7 +195,7 @@ message(
 )

 # Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
  message(
@ -326,7 +326,8 @@ if(FSFW_BUILD_TESTS)
            "/usr/local/include/*"
            "*/fsfw_tests/*"
            "*/catch2-src/*"
-            "*/fsfw_hal/*")
+            "*/fsfw_hal/*"
+            "unittests/*")
      endif()

      target_link_options(${FSFW_TEST_TGT} PRIVATE -fprofile-arcs
@ -344,8 +345,15 @@ if(FSFW_BUILD_TESTS)
          DEPENDENCIES ${FSFW_TEST_TGT})
      else()
        setup_target_for_coverage_lcov(
-          NAME ${FSFW_TEST_TGT}_coverage EXECUTABLE ${FSFW_TEST_TGT}
-          DEPENDENCIES ${FSFW_TEST_TGT})
+          NAME
+          ${FSFW_TEST_TGT}_coverage
+          EXECUTABLE
+          ${FSFW_TEST_TGT}
+          DEPENDENCIES
+          ${FSFW_TEST_TGT}
+          GENHTML_ARGS
+          --html-epilog
+          ${CMAKE_SOURCE_DIR}/unittests/lcov_epilog.html)
      endif()
    endif()
  endif()
@ -360,7 +368,8 @@ if(NOT FSFW_CONFIG_PATH)
  if(NOT FSFW_BUILD_DOCS)
    message(
      WARNING
-        "${MSG_PREFIX} Flight Software Framework configuration path not set")
+        "${MSG_PREFIX} Flight Software Framework configuration path FSFW_CONFIG_PATH not set"
+    )
    message(
      WARNING
        "${MSG_PREFIX} Setting default configuration from ${DEF_CONF_PATH} ..")
--- a/README.md
+++ b/README.md
@ -175,7 +175,7 @@ cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
 Then you can generate the documentation using

 ```sh
-cmake --build . -j
+cmake --build . -- Sphinx -j
 ```

 You can find the generated documentation inside the `docs/sphinx` folder inside the build
--- a/automation/Dockerfile
+++ b/automation/Dockerfile
@ -5,16 +5,25 @@ RUN apt-get --yes upgrade

 #tzdata is a dependency, won't install otherwise
 ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping
+RUN apt-get --yes install gcc g++ cmake make lcov git valgrind nano iputils-ping python3 pip doxygen graphviz rsync
+
+RUN python3 -m pip install sphinx breathe

 RUN git clone https://github.com/catchorg/Catch2.git && \
-	cd Catch2 && \
-	git checkout v3.0.0-preview5 && \
-	cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
-	cmake --build build/ --target install
+        cd Catch2 && \
+        git checkout v3.1.0 && \
+        cmake -Bbuild -H. -DBUILD_TESTING=OFF && \
+        cmake --build build/ --target install

 RUN git clone https://github.com/ETLCPP/etl.git && \
-	cd etl && \
-	git checkout 20.28.0 && \
-	cmake -B build . && \
-	cmake --install build/
+        cd etl && \
+        git checkout 20.28.0 && \
+        cmake -B build . && \
+        cmake --install build/
+
+#ssh needs a valid user to work
+RUN adduser --uid 114 jenkins
+
+#add documentation server to known hosts
+RUN echo "|1|/LzCV4BuTmTb2wKnD146l9fTKgQ=|NJJtVjvWbtRt8OYqFgcYRnMQyVw= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts
+RUN echo "|1|CcBvBc3EG03G+XM5rqRHs6gK/Gg=|oGeJQ+1I8NGI2THIkJsW92DpTzs= ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBNL8ssTonYtgiR/6RRlSIK9WU1ywOcJmxFTLcEblAwH7oifZzmYq3XRfwXrgfMpylEfMFYfCU8JRqtmi19xc21A=" >> /etc/ssh/ssh_known_hosts
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -1,9 +1,13 @@
 pipeline {
    environment {
        BUILDDIR = 'cmake-build-tests'
+        DOCDDIR = 'cmake-build-documentation'
    }
    agent {
-        docker { image 'fsfw-ci:d3'}
+        docker { 
+            image 'fsfw-ci:d6'
+            args '--network host'
+        }
    }
    stages {
        stage('Clean') {
@ -39,5 +43,43 @@ pipeline {
                }
            }
        }
+        stage('Documentation') {
+            when {
+                branch 'development'
+            }
+            steps {
+                dir(DOCDDIR) {
+                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
+                    sh 'make Sphinx'
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/development'
+                    }
+                }
+                dir(BUILDDIR) {
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/development'
+                    }
+                }
+            }
+        }
+        stage('Master Documentation') {
+            when {
+                branch 'master'
+            }
+            steps {
+                dir(DOCDDIR) {
+                    sh 'cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..'
+                    sh 'make Sphinx'
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete docs/sphinx/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/master'
+                    }
+                }
+                dir(BUILDDIR) {
+                    sshagent(credentials: ['documentation-buildfix']) {
+                        sh 'rsync -r --delete fsfw-tests_coverage/* buildfix@documentation.irs.uni-stuttgart.de:/fsfw/coverage/master'
+                    }
+                }
+            }
+        }
    }
 }
--- a/docs/README-config.md
+++ b/docs/README-config.md
@ -1,40 +0,0 @@
-Configuring the FSFW
-======
-
-The FSFW can be configured via the `fsfwconfig` folder. A template folder has
-been provided to have a starting point for this. The folder should be added
-to the include path. The primary configuration file is the `FSFWConfig.h` folder. Some
-of the available options will be explained in more detail here.
-
-# Auto-Translation of Events
-
-The FSFW allows the automatic translation of events, which allows developers to track triggered
-events directly via console output. Using this feature requires:
-
-1. `FSFW_OBJ_EVENT_TRANSLATION` set to 1 in the configuration file.
-2. Special auto-generated translation files which translate event IDs and object IDs into
-   human readable strings. These files can be generated using the 
-   [modgen Python scripts](https://git.ksat-stuttgart.de/source/modgen.git).
-3. The generated translation files for the object IDs should be named `translatesObjects.cpp`
-   and `translateObjects.h` and should be copied to the `fsfwconfig/objects` folder
-4. The generated translation files for the event IDs should be named `translateEvents.cpp` and
-   `translateEvents.h` and should be copied to the `fsfwconfig/events` folder
-   
-An example implementations of these translation file generators can be found as part
-of the [SOURCE project here](https://git.ksat-stuttgart.de/source/sourceobsw/-/tree/development/generators)
-or the [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example_public/src/branch/master/generators)
-
-## Configuring the Event Manager
-
-The number of allowed subscriptions can be modified with the following
-parameters:
-
-``` c++
-namespace fsfwconfig {
-//! Configure the allocated pool sizes for the event manager.
-static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
-static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
-static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
-}
-```
-
--- a/docs/README-controllers.md
+++ b/docs/README-controllers.md
@ -1 +0,0 @@
-## Controllers
--- a/docs/README-core.md
+++ b/docs/README-core.md
@ -1,55 +0,0 @@
-## FSFW Core Modules
-
-These core modules provide the most important functionalities of the 
-Flight Software Framework
-
-### Clock
-
- * This is a class of static functions that can be used at anytime
- * Leap Seconds must be set if any time conversions from UTC to other times is used
-
-### ObjectManager
-
-* Must be created during program startup
-* The component which handles all references. All SystemObjects register at this component. 
-* Any SystemObject needs to have a unique ObjectId. Those can be managed like objects::framework_objects.
-* A reference to an object can be get by calling the following function. T must be the specific Interface you want to call.
-A nullptr check of the returning Pointer must be done. This function is based on Run-time type information. 
-
-```cpp
-template <typename T> T* ObjectManagerIF::get( object_id_t id )
-```
-* A typical way to create all objects on startup is a handing a static produce function to the
-  ObjectManager on creation. By calling objectManager->initialize() the produce function will be
-  called and all SystemObjects will be initialized afterwards.
-
-### Event Manager
-
-* Component which allows routing of events
-* Other objects can subscribe to specific events, ranges of events or all events of an object.
-* Subscriptions can be done during runtime but should be done during initialization
-* Amounts of allowed subscriptions can be configured in `FSFWConfig.h`
-
-### Health Table
-
-* A component which holds every health state 
-* Provides a thread safe way to access all health states without the need of message exchanges
-
-### Stores
-
-* The message based communication can only exchange a few bytes of information inside the message
-  itself. Therefore, additional information can  be exchanged with Stores. With this, only the
-  store address must be exchanged in the message.
-* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC
-  Store is used. For outgoing TM a TM store is used.
-* All of them should use the Thread Safe Class storagemanager/PoolManager
-
-### Tasks
-
-There are two different types of tasks:
- * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the
-   insertion to the Tasks.
- * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for
-   DeviceHandlers, where polling should be in a defined order. An example can be found in 
-   `defaultcfg/fsfwconfig/pollingSequence` folder
-
--- a/docs/README-devicehandlers.md
+++ b/docs/README-devicehandlers.md
@ -1 +0,0 @@
-## Device Handlers
--- a/docs/README-highlevel.md
+++ b/docs/README-highlevel.md
@ -1,135 +0,0 @@
-High-level overview
-======
-
-# Structure
-
-The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be
-widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
-This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the
-FSFW to achieve that. The fsfw uses run-time type information but exceptions are not allowed.
-
-# Failure Handling
-
-Functions should return a defined `ReturnValue_t` to signal to the caller that something has
-gone wrong. Returnvalues must be unique. For this the function `returnvalue::makeCode`
-or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object.
-See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the
-`fsfwconfig` folder.
-
-# OSAL
-
-The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
-The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components
-and how to use them.
-
-# Core Components 
-
-The FSFW has following core components. More detailed informations can be found in the
-[core component section](doc/README-core.md#top):
-
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks 
-   with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID
-   to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands 
-   or small telemetry) in a pool structure without using dynamic memory allocation.
-   These pools are allocated up front.
-3. Clock: This module provided common time related functions
-4. EventManager: This module allows routing of events generated by `SystemObjects`
-5. HealthTable: A component which stores the health states of objects
-
-# Static IDs in the framework
-
-Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in `defaultcft/fsfwconfig/objects`
- inside the function `Factory::setStaticFrameworkObjectIds()`.
-
-# Events
-
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. 
-This works analog to the returnvalues. Every object that needs own EventIds has to get a
-unique SUBSYSTEM_ID. Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that
-has triggered.
-
-# Internal Communication
-
-Components communicate mostly via Messages through Queues. 
-Those queues are created by calling the singleton `QueueFactory::instance()->create()` which
-will create `MessageQueue` instances for the used OSAL.
-
-# External Communication
-
-The external communication with the mission control system is mostly up to the user implementation.
-The FSFW provides PUS Services which can be used to but don't need to be used. 
-The services can be seen as a conversion from a TC to a message based communication and back.
-
-## TMTC Communication
-
-The FSFW provides some components to facilitate TMTC handling via the PUS commands.
-For example, a UDP or TCP PUS server socket can be opened on a specific port using the
-files located in `osal/common`. The FSFW example uses this functionality to allow sending telecommands
-and receiving telemetry using the [TMTC commander application](https://github.com/spacefisch/tmtccmd).
-Simple commands like the PUS Service 17 ping service can be tested by simply running the
-`tmtc_client_cli.py` or `tmtc_client_gui.py` utility in 
-the [example tmtc folder](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example_public/src/branch/master/tmtc)
-while the `fsfw_example` application is running.
-
-More generally, any class responsible for handling incoming telecommands and sending telemetry
-can implement the generic `TmTcBridge` class located in `tmtcservices`. Many applications
-also use a dedicated polling task for reading telecommands which passes telecommands
-to the `TmTcBridge` implementation.
-
-## CCSDS Frames, CCSDS Space Packets and PUS
-
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to
-distributed the packets to the corresponding services. Those can be found in `tcdistribution`. 
-If Space Packets are used, a timestamper has to be provided by the user. 
-An example can be found in the `timemanager` folder, which uses `CCSDSTime::CDS_short`.
-
-# Device Handlers
-
-DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode,
-health and commanding interface. By separating the underlying Communication Interface with 
-`DeviceCommunicationIF`, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow
-for FDIR reaction.  Device Handlers can be created by implementing `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can
-be overwritten by the user. More information on DeviceHandlers can be found in the
-related [documentation section](doc/README-devicehandlers.md#top).
-
-# Modes and Health
-
-The two interfaces `HasModesIF` and `HasHealthIF` provide access for commanding and monitoring
-of components. On-board Mode Management is implement in hierarchy system. 
-DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle
-redundancies of handlers. Assemblies share a common core with the next level which
-are the Subsystems. 
-
-Those Assemblies are intended to act as auto-generated components from a database which describes
-the subsystem modes. The definitions contain transition and target tables which contain the DH,
-Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a
-switch into any higher AOCS mode might first turn on the sensors, than the actuators and the
-controller as last component. 
-The target table is used to describe the state that is checked continuously by the subsystem. 
-All of this allows System Modes to be generated as Subsystem object as well from the same database. 
-This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because
-only the highest components must be commanded.
-
-The health state represents if the component is able to perform its tasks. 
-This can be used to signal the system to avoid using this component instead of a redundant one.
-The on-board FDIR uses the health state for isolation and recovery. 
-
-# Unit Tests
-
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include
-catch2 itself. More information on how to run these tests can be found in the separate
-[`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)
--- a/docs/README-localpools.md
+++ b/docs/README-localpools.md
@ -1,174 +0,0 @@
-## Local Data Pools Developer Information
-
-The following text is targeted towards mission software developers which would like
-to use the local data pools provided by the FSFW to store data like sensor values so they can be 
-used by other software objects like controllers as well. If a custom class should have a local 
-pool which  can be used by other software objects as well, following steps have to be performed:
-
-1. Create a `LocalDataPoolManager` member object in the custom class
-2. Implement the `HasLocalDataPoolIF` with specifies the interface between the local pool manager
-and the class owning the local pool.
-
-The local data pool manager is also able to process housekeeping service requests in form
-of messages, generate periodic housekeeping packet, generate notification and snapshots of changed
-variables and datasets and process notifications and snapshots coming from other objects.
-The two former tasks are related to the external interface using telemetry and telecommands (TMTC)
-while the later two are related to data consumers like controllers only acting on data change 
-detected by the data creator instead of checking the data manually each cycle. Two important 
-framework classes `DeviceHandlerBase` and `ExtendedControllerBase` already perform the two steps 
-shown above so the steps required are altered slightly.
-
-### Storing and Accessing pool data 
-
-The pool manager is responsible for thread-safe access of the pool data, but the actual
-access to the pool data from the point of view of a mission software developer happens via proxy
-classes like pool variable classes. These classes store a copy
-of the pool variable with the matching datatype and copy the actual data from the local pool
-on a `read` call. Changed variables can then be written to the local pool with a `commit` call.
-The `read` and `commit` calls are thread-safe and can be called concurrently from data creators
-and data consumers. Generally, a user will create a dataset class which in turn groups all 
-cohesive pool variables. These sets simply iterator over the list of variables and call the 
-`read` and `commit` functions of each variable. The following diagram shows the
-high-level architecture of the local data pools.
-
-.. image:: ../misc/logo/FSFW_Logo_V3_bw.png
-   :alt: FSFW Logo
-
-
-An example is shown for using the local data pools with a Gyroscope.
-For example, the following code shows an implementation to access data from a Gyroscope taken
-from the SOURCE CubeSat project:
-
-```cpp
-class GyroPrimaryDataset: public StaticLocalDataSet<3 * sizeof(float)> {
-public:
-    /**
-     * Constructor for data users
-     * @param gyroId
-     */
-    GyroPrimaryDataset(object_id_t gyroId):
-            StaticLocalDataSet(sid_t(gyroId, gyrodefs::GYRO_DATA_SET_ID)) {
-        setAllVariablesReadOnly();
-    }
-
-    lp_var_t<float> angVelocityX = lp_var_t<float>(sid.objectId,
-            gyrodefs::ANGULAR_VELOCITY_X, this);
-    lp_var_t<float> angVelocityY = lp_var_t<float>(sid.objectId,
-            gyrodefs::ANGULAR_VELOCITY_Y, this);
-    lp_var_t<float> angVelocityZ = lp_var_t<float>(sid.objectId,
-            gyrodefs::ANGULAR_VELOCITY_Z, this);
-private:
-
-    friend class GyroHandler;
-    /**
-     * Constructor for data creator
-     * @param hkOwner
-     */
-    GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner):
-            StaticLocalDataSet(hkOwner, gyrodefs::GYRO_DATA_SET_ID) {}
-};
-```
-
-There is a public constructor for users which sets all variables to read-only and there is a
-constructor for the GyroHandler data creator by marking it private and declaring the `GyroHandler`
-as a friend class. Both the atittude controller and the `GyroHandler` can now
-use the same class definition to access the pool variables with `read` and `commit` semantics
-in a thread-safe way. Generally, each class requiring access will have the set class as a member
-class. The data creator will also be generally a `DeviceHandlerBase` subclass and some additional
-steps are necessary to expose the set for housekeeping purposes.
-
-### Using the local data pools in a `DeviceHandlerBase` subclass
-
-It is very common to store data generated by devices like a sensor into a pool which can 
-then be used by other objects. Therefore, the `DeviceHandlerBase` already has a
-local pool. Using the aforementioned example, our `GyroHandler` will now have the set class
-as a member:
-
-```cpp
-class GyroHandler: ... {
-
-public:
-	...
-private:
-	...
-	GyroPrimaryDataset gyroData;
-	...
-};
-```
-
-The constructor used for the creators expects the owner class as a parameter, so we initialize
-the object in the `GyroHandler` constructor like this:
-
-```cpp
-GyroHandler::GyroHandler(object_id_t objectId, object_id_t comIF,
-        CookieIF *comCookie, uint8_t switchId):
-        DeviceHandlerBase(objectId, comIF, comCookie), switchId(switchId),
-		gyroData(this) {}
-```
-
-We need to assign the set to a reply ID used in the `DeviceHandlerBase`. 
-The combination of the `GyroHandler` object ID and the reply ID will be the 64-bit structure ID
-`sid_t` and is used to globally identify the set, for example when requesting housekeeping data or
-generating update messages. We need to assign our custom set class in some way so that the local 
-pool manager can access the custom data sets as well.
-By default, the `getDataSetHandle` will take care of this tasks. The default implementation for a
-`DeviceHandlerBase` subclass will use the internal command map to retrieve 
-a handle to a dataset from a given reply ID. Therefore,
-we assign the set in the `fillCommandAndReplyMap` function:
-
-```cpp
-void GyroHandler::fillCommandAndReplyMap() {
-	...
-	this->insertInCommandAndReplyMap(gyrodefs::GYRO_DATA, 3, &gyroData);
-	...
-}
-```
-
-Now, we need to create the actual pool entries as well, using the `initializeLocalDataPool` 
-function. Here, we also immediately subscribe for periodic housekeeping packets 
-with an interval of 4 seconds. They are still disabled in this example and can be enabled 
-with a housekeeping service command.
-
-```cpp
-ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-		LocalDataPoolManager &poolManager) {
-	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_X,
-			new PoolEntry<float>({0.0}));
-	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Y,
-			new PoolEntry<float>({0.0}));
-	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Z,
-			new PoolEntry<float>({0.0}));
-	localDataPoolMap.emplace(gyrodefs::GENERAL_CONFIG_REG42,
-			new PoolEntry<uint8_t>({0}));
-	localDataPoolMap.emplace(gyrodefs::RANGE_CONFIG_REG43,
-			new PoolEntry<uint8_t>({0}));
-
-	poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
-	return returnvalue::OK;
-}
-```
-
-Now, if we receive some sensor data and converted them into the right format, 
-we can write it into the pool like this, using a guard class to ensure the set is commited back 
-in any case:
-
-```cpp
-PoolReadGuard readHelper(&gyroData);
-if(readHelper.getReadResult() == returnvalue::OK) {
-	if(not gyroData.isValid()) {
-		gyroData.setValidity(true, true);
-	}
-
-	gyroData.angVelocityX = angularVelocityX;
-	gyroData.angVelocityY = angularVelocityY;
-	gyroData.angVelocityZ = angularVelocityZ;
-}
-```
-
-The guard class will commit the changed data on destruction automatically.
-
-### Using the local data pools in a `ExtendedControllerBase` subclass
-
-Coming soon
-
-
--- a/docs/README-osal.md
+++ b/docs/README-osal.md
@ -1,32 +0,0 @@
-# Operating System Abstraction Layer (OSAL)
-
-Some specific information on the provided OSALs are provided.
-
-## Linux OSAL
-
-This OSAL can be used to compile for Linux host systems like Ubuntu 20.04 or for 
-embedded Linux targets like the Raspberry Pi. This OSAL generally requires threading support
-and real-time functionalities. For most UNIX systems, this is done by adding `-lrt` and `-lpthread` to the linked libraries in the compilation process. The CMake build support provided will do this automatically for the `fsfw` target. It should be noted that most UNIX systems need to be configured specifically to allow the real-time functionalities required by the FSFW.
-
-More information on how to set up a Linux system accordingly can be found in the 
-[Linux README of the FSFW example application](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/master/doc/README-linux.md#top)
-
-## Hosted OSAL
-
-This is the newest OSAL. Support for Semaphores has not been implemented yet and will propably be implemented as soon as C++20 with Semaphore support has matured. This OSAL can be used to run the FSFW on any host system, but currently has only been tested on Windows 10 and Ubuntu 20.04. Unlike the other OSALs, it uses dynamic memory allocation (e.g. for the message queue implementation). Cross-platform serial port (USB) support might be added soon.
-
-## FreeRTOS OSAL
-
-FreeRTOS is not included and the developer needs to take care of compiling the FreeRTOS sources and adding the `FreeRTOSConfig.h` file location to the include path. This OSAL has only been tested extensively with the pre-emptive scheduler configuration so far but it should in principle also be possible to use a cooperative scheduler. It is recommended to use the `heap_4` allocation scheme. When using newlib (nano), it is also recommended to add `#define configUSE_NEWLIB_REENTRANT` to the FreeRTOS configuration file to ensure thread-safety.
-
-When using this OSAL, developers also need to provide an implementation for the `vRequestContextSwitchFromISR` function. This has been done because the call to request a context switch from an ISR is generally located in the `portmacro.h` header and is different depending on the target architecture or device.
-
-## RTEMS OSAL
-
-The RTEMS OSAL was the first implemented OSAL which is also used on the active satellite Flying Laptop.
-
-## TCP/IP socket abstraction
-
-The Linux and Host OSAL provide abstraction layers for the socket API. Currently, only UDP sockets have been imlemented. This is very useful to test TMTC handling either on the host computer directly (targeting localhost with a TMTC application) or on embedded Linux devices, sending TMTC packets via Ethernet.
-
-
--- a/docs/README-pus.md
+++ b/docs/README-pus.md
@ -1 +0,0 @@
-## PUS Services
--- a/docs/conf.py
+++ b/docs/conf.py
@ -50,6 +50,11 @@ exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
 #
 html_theme = 'alabaster'

+html_theme_options = {
+    "extra_nav_links": {"Impressum" : "https://www.uni-stuttgart.de/impressum", "Datenschutz": "https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html"}
+}
+
+
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
--- a/docs/highlevel.rst
+++ b/docs/highlevel.rst
@ -6,13 +6,14 @@ High-level overview
 Structure
 ----------

-The general structure is driven by the usage of interfaces provided by objects.
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be
-widely available, even with older compilers.
-The FSFW uses dynamic allocation during the initialization but provides static containers during runtime.
-This simplifies the instantiation of objects and allows the usage of some standard containers.
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the
-FSFW to achieve that. The fsfw uses run-time type information but exceptions are not allowed.
+The general structure is driven by the usage of interfaces provided by objects. 
+The FSFW uses C++17 as baseline. Most modern compilers like GCC should have support for this
+standard, even for micocontrollers.
+
+The FSFW might use dynamic allocation during program initialization but not during runtime.
+It offers pool objects, static containers and it also exposes the
+`Embedded Template Library <https://www.etlcpp.com/>`_ to allow writing code which does not perform
+allocation during runtime. The fsfw uses run-time type information but will not throw exceptions.

 Failure Handling
 -----------------
--- a/misc/defaultcfg/fsfwconfig/FSFWConfig.h
+++ b/misc/defaultcfg/fsfwconfig/FSFWConfig.h
@ -4,6 +4,10 @@
 #include <cstddef>
 #include <cstdint>

+// It is assumed the user has a subsystem and class ID list in some user header files.
+// #include "events/subsystemIdRanges.h"
+// #include "returnvalues/classIds.h"
+
 //! Used to determine whether C++ ostreams are used which can increase
 //! the binary size significantly. If this is disabled,
 //! the C stdio functions can be used alternatively
--- a/misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
+++ b/misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
@ -4,7 +4,6 @@
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
-#include <fsfw/tmtcpacket/pus/tm/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <fsfw/internalerror/InternalErrorReporter.h>
@ -41,13 +40,9 @@ void Factory::setStaticFrameworkObjectIds() {
 	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
 	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;

-	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-
 	DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 	DeviceHandlerBase::rawDataReceiverId = objects::PUS_SERVICE_2_DEVICE_ACCESS;

 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
-
-	TmPacketBase::timeStamperId = objects::NO_OBJECT;
 }

--- a/scripts/helper.py
+++ b/scripts/helper.py
@ -199,7 +199,7 @@ def check_for_cmake_build_dir(build_dir_list: list) -> list:
 def perform_lcov_operation(directory: str, chdir: bool):
    if chdir:
        os.chdir(directory)
-    cmd_runner("cmake --build . -- fsfw-tests_coverage -j")
+    cmd_runner("cmake --build . -j -- fsfw-tests_coverage")


 def determine_build_dir(build_dir_list: List[str]):
--- 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/CfdpHandler.cpp
+++ b/src/fsfw/cfdp/CfdpHandler.cpp
@ -11,9 +11,7 @@ object_id_t CfdpHandler::packetDestination = 0;

 CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
    : SystemObject(setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  requestQueue = QueueFactory::instance()->createMessageQueue(
-      CFDP_HANDLER_MAX_RECEPTION, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  requestQueue = QueueFactory::instance()->createMessageQueue(CFDP_HANDLER_MAX_RECEPTION);
  distributor = dist;
 }

@ -53,6 +51,6 @@ ReturnValue_t CfdpHandler::performOperation(uint8_t opCode) {
  return returnvalue::OK;
 }

-uint16_t CfdpHandler::getIdentifier() { return 0; }
+uint32_t CfdpHandler::getIdentifier() const { return 0; }

-MessageQueueId_t CfdpHandler::getRequestQueue() { return this->requestQueue->getId(); }
+MessageQueueId_t CfdpHandler::getRequestQueue() const { return this->requestQueue->getId(); }
--- a/src/fsfw/cfdp/CfdpHandler.h
+++ b/src/fsfw/cfdp/CfdpHandler.h
@ -25,8 +25,8 @@ class CfdpHandler : public ExecutableObjectIF, public AcceptsTelecommandsIF, pub
  virtual ReturnValue_t handleRequest(store_address_t storeId);

  virtual ReturnValue_t initialize() override;
-  virtual uint16_t getIdentifier() override;
-  MessageQueueId_t getRequestQueue() override;
+  uint32_t getIdentifier() const override;
+  MessageQueueId_t getRequestQueue() const override;
  ReturnValue_t performOperation(uint8_t opCode) override;

 protected:
--- a/src/fsfw/cfdp/tlv/Lv.cpp
+++ b/src/fsfw/cfdp/tlv/Lv.cpp
@ -21,7 +21,7 @@ cfdp::Lv& cfdp::Lv::operator=(const Lv& other) {
  if (value == nullptr or otherSize == 0) {
    this->zeroLen = true;
  }
-  this->value.setBuffer(value, otherSize);
+  this->value.setConstBuffer(value, otherSize);
  return *this;
 }

@ -70,7 +70,7 @@ ReturnValue_t cfdp::Lv::deSerialize(const uint8_t** buffer, size_t* size,
  }
  zeroLen = false;
  // Zero-copy implementation
-  value.setBuffer(const_cast<uint8_t*>(*buffer + 1), lengthField);
+  value.setConstBuffer(*buffer + 1, lengthField);
  *buffer += 1 + lengthField;
  *size -= 1 + lengthField;
  return returnvalue::OK;
--- a/src/fsfw/cfdp/tlv/Tlv.cpp
+++ b/src/fsfw/cfdp/tlv/Tlv.cpp
@ -75,7 +75,7 @@ ReturnValue_t cfdp::Tlv::deSerialize(const uint8_t **buffer, size_t *size,
  }
  zeroLen = false;
  // Zero-copy implementation
-  value.setBuffer(const_cast<uint8_t *>(*buffer + 1), lengthField);
+  value.setConstBuffer(*buffer + 1, lengthField);
  *buffer += 1 + lengthField;
  *size -= 1 + lengthField;
  return returnvalue::OK;
@ -96,7 +96,7 @@ void cfdp::Tlv::setValue(uint8_t *value, size_t len) {
  if (len > 0) {
    zeroLen = false;
  }
-  this->value.setBuffer(value, len);
+  this->value.setConstBuffer(value, len);
 }

 uint8_t cfdp::Tlv::getLengthField() const { return this->value.getSerializedSize() - 1; }
--- a/src/fsfw/controller/ControllerBase.cpp
+++ b/src/fsfw/controller/ControllerBase.cpp
@ -13,9 +13,7 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
      submode(SUBMODE_NONE),
      modeHelper(this),
      healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
 }

 ControllerBase::~ControllerBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
+++ b/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
@ -570,10 +570,6 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* me

  CommandMessage reply;
  if (result != returnvalue::OK) {
-    if (result == WRONG_HK_PACKET_TYPE) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
-                          WRONG_HK_PACKET_TYPE);
-    }
    HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
  } else {
    HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
@ -829,8 +825,6 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
      errorPrint = "Dataset not found";
    } else if (error == POOLOBJECT_NOT_FOUND) {
      errorPrint = "Pool Object not found";
-    } else if (error == WRONG_HK_PACKET_TYPE) {
-      errorPrint = "Wrong Packet Type";
    } else if (error == returnvalue::FAILED) {
      if (outputType == sif::OutputTypes::OUT_WARNING) {
        errorPrint = "Generic Warning";
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
+++ b/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
@ -162,7 +162,6 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
  object_id_t getCreatorObjectId();

  bool getReportingEnabled() const;
-  void setReportingEnabled(bool enabled);

  /**
   * Returns the current periodic HK generation interval this set
@ -190,6 +189,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
   * Used for periodic generation.
   */
  bool reportingEnabled = false;
+  void setReportingEnabled(bool enabled);

  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
                                uint8_t nonDiagIntervalFactor = 5);
--- a/src/fsfw/devicehandlers/AssemblyBase.cpp
+++ b/src/fsfw/devicehandlers/AssemblyBase.cpp
@ -26,7 +26,11 @@ void AssemblyBase::performChildOperation() {

 void AssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
  doStartTransition(mode, submode);
-  triggerModeHelperEvents(mode, submode);
+  if (modeHelper.isForced()) {
+    triggerEvent(FORCING_MODE, mode, submode);
+  } else {
+    triggerEvent(CHANGING_MODE, mode, submode);
+  }
 }

 void AssemblyBase::doStartTransition(Mode_t mode, Submode_t submode) {
@ -73,10 +77,9 @@ bool AssemblyBase::handleChildrenChangedHealth() {
  }
  HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
  if (healthState == HasHealthIF::NEEDS_RECOVERY) {
-    triggerEvent(TRYING_RECOVERY, iter->first, 0);
+    triggerEvent(TRYING_RECOVERY);
    recoveryState = RECOVERY_STARTED;
    recoveringDevice = iter;
-    // The user needs to take care of commanding the children off in commandChildren
    doStartTransition(targetMode, targetSubmode);
  } else {
    triggerEvent(CHILD_CHANGED_HEALTH);
@ -225,9 +228,6 @@ ReturnValue_t AssemblyBase::handleHealthReply(CommandMessage* message) {
 bool AssemblyBase::checkAndHandleRecovery() {
  switch (recoveryState) {
    case RECOVERY_STARTED:
-      // The recovery was already start in #handleChildrenChangedHealth and we just need
-      // to wait for an off time period.
-      // TODO: make time period configurable
      recoveryState = RECOVERY_WAIT;
      recoveryOffTimer.resetTimer();
      return true;
@ -266,11 +266,3 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
  modeHelper.setForced(true);
  sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }
-
-void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
-  if (modeHelper.isForced()) {
-    triggerEvent(FORCING_MODE, mode, submode);
-  } else {
-    triggerEvent(CHANGING_MODE, mode, submode);
-  }
-}
--- a/src/fsfw/devicehandlers/AssemblyBase.h
+++ b/src/fsfw/devicehandlers/AssemblyBase.h
@ -12,8 +12,7 @@
 * Documentation: Dissertation Baetz p.156, 157.
 *
 * This class reduces the complexity of controller components which would
- * otherwise be needed for the handling of redundant devices. However, it can also be used to
- * manage the mode keeping and recovery of non-redundant devices
+ * otherwise be needed for the handling of redundant devices.
 *
 * The template class monitors mode and health state of its children
 * and checks availability of devices on every detected change.
@ -27,9 +26,11 @@
 *
 * Important:
 *
- * The implementation must call #registerChild for all commanded children during initialization.
+ * The implementation must call registerChild(object_id_t child)
+ * for all commanded children during initialization.
 * The implementation must call the initialization function of the base class.
 * (This will call the function in SubsystemBase)
+ *
 */
 class AssemblyBase : public SubsystemBase {
 public:
@ -46,10 +47,9 @@ class AssemblyBase : public SubsystemBase {

 protected:
  /**
-   * Command children to reach [mode,submode] combination. Can be done by setting
-   * #commandsOutstanding correctly, or using #executeTable. In case of an FDIR recovery,
-   * the user needs to ensure that the target devices are healthy. If a device is not healthy,
-   * a recovery might be on-going and the device needs to be commanded to off first.
+   * Command children to reach [mode,submode] combination
+   * Can be done by setting #commandsOutstanding correctly,
+   * or using executeTable()
   * @param mode
   * @param submode
   * @return
@ -120,19 +120,8 @@ class AssemblyBase : public SubsystemBase {

  virtual ReturnValue_t handleHealthReply(CommandMessage *message);

-  /**
-   * @brief Default periodic handler
-   * @details
-   * This is the default periodic handler which will be called by the SubsystemBase
-   * performOperation. It performs the child transitions or reacts to changed health/mode states
-   * of children objects
-   */
-  virtual void performChildOperation() override;
+  virtual void performChildOperation();

-  /**
-   * This function handles changed mode or health states of children
-   * @return
-   */
  bool handleChildrenChanged();

  /**
@ -145,37 +134,12 @@ class AssemblyBase : public SubsystemBase {

  bool handleChildrenChangedHealth();

-  /**
-   * Core transition handler. The default implementation will only do something if
-   * #commandsOutstanding is smaller or equal to zero, which means that all mode commands
-   * from the #doPerformTransition call were executed successfully.
-   *
-   * Unless a second step was requested, the function will then use #checkChildrenState to
-   * determine whether the target mode was reached.
-   *
-   * There is some special handling for certain (internal) modes:
-   *  - A second step is necessary. #commandChildren will be performed again
-   *  - The device health was overwritten. #commandChildren will be called
-   *  - A recovery is ongoing. #checkAndHandleRecovery will be called.
-   */
  virtual void handleChildrenTransition();

  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t *msToReachTheMode);

-  /**
-   * Calls #doStartTransition and triggers an informative event as well that the mode will
-   * change
-   * @param mode
-   * @param submode
-   */
  virtual void startTransition(Mode_t mode, Submode_t submode);

-  /**
-   * This function starts the transition by setting the internal #targetSubmode and #targetMode
-   * variables and then calling the #commandChildren function.
-   * @param mode
-   * @param submode
-   */
  virtual void doStartTransition(Mode_t mode, Submode_t submode);

  virtual bool isInTransition();
@ -196,7 +160,7 @@ class AssemblyBase : public SubsystemBase {
   * Manages recovery of a device
   * @return true if recovery is still ongoing, false else.
   */
-  virtual bool checkAndHandleRecovery();
+  bool checkAndHandleRecovery();

  /**
   * Helper method to overwrite health state of one of the children.
@ -204,8 +168,6 @@ class AssemblyBase : public SubsystemBase {
   * @param objectId Must be a registered child.
   */
  void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);
-
-  void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
 };

 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
@ -22,8 +22,6 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
                                     CookieIF* comCookie, FailureIsolationBase* fdirInstance,
                                     size_t cmdQueueSize)
    : SystemObject(setObjectId),
-      mode(MODE_OFF),
-      submode(SUBMODE_NONE),
      wiretappingMode(OFF),
      storedRawData(StorageManagerIF::INVALID_ADDRESS),
      deviceCommunicationId(deviceCommunication),
@ -38,11 +36,12 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
      defaultFDIRUsed(fdirInstance == nullptr),
      switchOffWasReported(false),
      childTransitionDelay(5000),
+      mode(MODE_OFF),
+      submode(SUBMODE_NONE),
      transitionSourceMode(_MODE_POWER_DOWN),
      transitionSourceSubMode(SUBMODE_NONE) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
  commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
  insertInCommandMap(RAW_COMMAND_ID);
  cookieInfo.state = COOKIE_UNUSED;
  cookieInfo.pendingCommand = deviceCommandMap.end();
@ -50,6 +49,9 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
    printWarningOrError(sif::OutputTypes::OUT_ERROR, "DeviceHandlerBase", returnvalue::FAILED,
                        "Invalid cookie");
  }
+  if (this->fdirInstance == nullptr) {
+    this->fdirInstance = new DeviceHandlerFailureIsolation(setObjectId, defaultFdirParentId);
+  }
 }

 void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
@ -127,18 +129,6 @@ ReturnValue_t DeviceHandlerBase::initialize() {
  if (result != returnvalue::OK) {
    return result;
  }
-  if (this->fdirInstance == nullptr) {
-    this->fdirInstance =
-        new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
-  }
-
-  if (this->parent != objects::NO_OBJECT) {
-    HasModesIF* modeIF = ObjectManager::instance()->get<HasModesIF>(this->parent);
-    HasHealthIF* healthIF = ObjectManager::instance()->get<HasHealthIF>(this->parent);
-    if (modeIF != nullptr and healthIF != nullptr) {
-      setParentQueue(modeIF->getCommandQueue());
-    }
-  }

  communicationInterface =
      ObjectManager::instance()->get<DeviceCommunicationIF>(deviceCommunicationId);
@ -362,7 +352,6 @@ void DeviceHandlerBase::doStateMachine() {
          currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
        triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
        setMode(_MODE_POWER_DOWN);
-        callChildStatemachine();
        break;
      }
      ReturnValue_t switchState = getStateOfSwitches();
@ -374,12 +363,13 @@ void DeviceHandlerBase::doStateMachine() {
      }
    } break;
    case _MODE_WAIT_OFF: {
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
+
      if (powerSwitcher == nullptr) {
        setMode(MODE_OFF);
        break;
      }
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
      if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
        triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
        setMode(MODE_ERROR_ON);
@ -467,7 +457,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandMap(DeviceCommandId_t deviceComm
  info.expectedReplies = 0;
  info.isExecuting = false;
  info.sendReplyTo = NO_COMMANDER;
-  info.useAlternativeReplyId = alternativeReplyId;
+  info.useAlternativeReplyId = useAlternativeReply;
  info.alternativeReplyId = alternativeReplyId;
  auto resultPair = deviceCommandMap.emplace(deviceCommand, info);
  if (resultPair.second) {
@ -526,16 +516,16 @@ ReturnValue_t DeviceHandlerBase::updatePeriodicReply(bool enable, DeviceCommandI
    if (enable) {
      info->active = true;
      if (info->countdown != nullptr) {
-        info->delayCycles = info->maxDelayCycles;
-      } else {
        info->countdown->resetTimer();
+      } else {
+        info->delayCycles = info->maxDelayCycles;
      }
    } else {
      info->active = false;
      if (info->countdown != nullptr) {
-        info->delayCycles = 0;
-      } else {
        info->countdown->timeOut();
+      } else {
+        info->delayCycles = 0;
      }
    }
  }
@ -576,14 +566,23 @@ void DeviceHandlerBase::setTransition(Mode_t modeTo, Submode_t submodeTo) {
 void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
  /* TODO: This will probably be done by the LocalDataPoolManager now */
  // changeHK(mode, submode, false);
+
+  /**
+   * handle transition from OFF to NORMAL by continuing towards normal when ON is reached
+   */
+  if (newMode == MODE_ON and continueToNormal) {
+    continueToNormal = false;
+    mode = _MODE_TO_NORMAL;
+    return;
+  }
+
  submode = newSubmode;
  mode = newMode;
  modeChanged();
  setNormalDatapoolEntriesInvalid();
-  if (newMode == MODE_OFF) {
-    disableCommandsAndReplies();
-  }
  if (!isTransitionalMode()) {
+    // clear this flag when a non-transitional Mode is reached to be safe
+    continueToNormal = false;
    modeHelper.modeChanged(newMode, newSubmode);
    announceMode(false);
  }
@ -1068,8 +1067,7 @@ Mode_t DeviceHandlerBase::getBaseMode(Mode_t transitionMode) {
  return transitionMode & ~(TRANSITION_MODE_BASE_ACTION_MASK | TRANSITION_MODE_CHILD_ACTION_MASK);
 }

-// SHOULDDO: Allow transition from OFF to NORMAL to reduce complexity in assemblies. And, by the
-// way, throw away DHB and write a new one:
+// SHOULDDO: throw away DHB and write a new one:
 //  - Include power and thermal completely, but more modular :-)
 //  - Don't use modes for state transitions, reduce FSM (Finte State Machine) complexity.
 //  - Modularization?
@ -1081,11 +1079,10 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode, Submode_
  if ((mode == MODE_ERROR_ON) && (commandedMode != MODE_OFF)) {
    return TRANS_NOT_ALLOWED;
  }
-  if ((commandedMode == MODE_NORMAL) && (mode == MODE_OFF)) {
-    return TRANS_NOT_ALLOWED;
-  }

-  if ((commandedMode == MODE_ON) && (mode == MODE_OFF) and (thermalSet != nullptr)) {
+  // Do not check thermal state for MODE_RAW
+  if ((mode == MODE_OFF) and ((commandedMode == MODE_ON) or (commandedMode == MODE_NORMAL)) and
+      (thermalSet != nullptr)) {
    ReturnValue_t result = thermalSet->read();
    if (result == returnvalue::OK) {
      if ((thermalSet->heaterRequest.value != ThermalComponentIF::STATE_REQUEST_IGNORE) and
@ -1100,6 +1097,7 @@ ReturnValue_t DeviceHandlerBase::checkModeCommand(Mode_t commandedMode, Submode_
 }

 void DeviceHandlerBase::startTransition(Mode_t commandedMode, Submode_t commandedSubmode) {
+  continueToNormal = false;
  switch (commandedMode) {
    case MODE_ON:
      handleTransitionToOnMode(commandedMode, commandedSubmode);
@ -1129,8 +1127,9 @@ void DeviceHandlerBase::startTransition(Mode_t commandedMode, Submode_t commande
    case MODE_NORMAL:
      if (mode != MODE_OFF) {
        setTransition(MODE_NORMAL, commandedSubmode);
-      } else {
-        replyReturnvalueToCommand(HasModesIF::TRANS_NOT_ALLOWED);
+      } else {  // mode is off
+        continueToNormal = true;
+        handleTransitionToOnMode(MODE_NORMAL, commandedSubmode);
      }
      break;
  }
@ -1288,7 +1287,6 @@ void DeviceHandlerBase::handleDeviceTm(const SerializeIF& dataSet, DeviceCommand
  if (iter->second.command != deviceCommandMap.end()) {
    MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;

-    // This may fail, but we'll ignore the fault.
    if (queueId != NO_COMMANDER) {
      // This may fail, but we'll ignore the fault.
      actionHelper.reportData(queueId, replyId, const_cast<SerializeIF*>(&dataSet));
@ -1331,13 +1329,11 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
    return result;
  }
  DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-  MessageQueueId_t prevRecipient = MessageQueueIF::NO_QUEUE;
  if (iter == deviceCommandMap.end()) {
    result = COMMAND_NOT_SUPPORTED;
  } else if (iter->second.isExecuting) {
    result = COMMAND_ALREADY_SENT;
  } else {
-    prevRecipient = iter->second.sendReplyTo;
    iter->second.sendReplyTo = commandedBy;
    result = buildCommandFromCommand(actionId, data, size);
  }
@ -1345,8 +1341,6 @@ ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueue
    iter->second.isExecuting = true;
    cookieInfo.pendingCommand = iter;
    cookieInfo.state = COOKIE_WRITE_READY;
-  } else {
-    iter->second.sendReplyTo = prevRecipient;
  }
  return result;
 }
@ -1471,8 +1465,6 @@ void DeviceHandlerBase::setTaskIF(PeriodicTaskIF* task) { executingTask = task;
 void DeviceHandlerBase::debugInterface(uint8_t positionTracker, object_id_t objectId,
                                       uint32_t parameter) {}

-Submode_t DeviceHandlerBase::getInitialSubmode() { return SUBMODE_NONE; }
-
 void DeviceHandlerBase::performOperationHook() {}

 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@ -1495,7 +1487,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
  this->poolManager.initializeAfterTaskCreation();

  if (setStartupImmediately) {
-    startTransition(MODE_ON, getInitialSubmode());
+    startTransition(MODE_ON, SUBMODE_NONE);
  }
  return returnvalue::OK;
 }
@ -1579,29 +1571,3 @@ MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyI
  }
  return commandIter->second.sendReplyTo;
 }
-
-void DeviceHandlerBase::setCustomFdir(FailureIsolationBase* fdir) { this->fdirInstance = fdir; }
-
-void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
-
-void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
-  this->powerSwitcher = switcher;
-}
-
-void DeviceHandlerBase::disableCommandsAndReplies() {
-  for (auto& command : deviceCommandMap) {
-    if (command.second.isExecuting) {
-      command.second.isExecuting = false;
-    }
-  }
-  for (auto& reply : deviceReplyMap) {
-    if (!reply.second.periodic) {
-      if (reply.second.countdown != nullptr) {
-        reply.second.countdown->timeOut();
-      } else {
-        reply.second.delayCycles = 0;
-      }
-      reply.second.active = false;
-    }
-  }
-}
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@ -23,7 +23,6 @@
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/util/dataWrapper.h"

 namespace Factory {
 void setStaticFrameworkObjectIds();
@ -103,9 +102,53 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF *comCookie,
                    FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);

-  void setCustomFdir(FailureIsolationBase *fdir);
-  void setParent(object_id_t parent);
-  void setPowerSwitcher(PowerSwitchIF *switcher);
+  /**
+   * extending the modes of DeviceHandler IF for internal state machine
+   */
+  static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
+  static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
+  //! This is a transitional state which can not be commanded. The device
+  //! handler performs all commands to get the device in a state ready to
+  //! perform commands. When this is completed, the mode changes to @c MODE_ON.
+  static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
+  //! This is a transitional state which can not be commanded.
+  //! The device handler performs all actions and commands to get the device
+  //! shut down. When the device is off, the mode changes to @c MODE_OFF.
+  //! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
+  //! transition if available.
+  static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
+  //! It is possible to set the mode to _MODE_TO_ON to use the to on
+  //! transition if available.
+  static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
+  //! It is possible to set the mode to _MODE_TO_RAW to use the to raw
+  //! transition if available.
+  static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
+  //! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
+  //! transition if available.
+  static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
+  //! This is a transitional state which can not be commanded.
+  //! The device is shut down and ready to be switched off.
+  //! After the command to set the switch off has been sent,
+  //! the mode changes to @c _MODE_WAIT_OFF
+  static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
+  //! This is a transitional state which can not be commanded. The device
+  //! will be switched on in this state. After the command to set the switch
+  //! on has been sent, the mode changes to @c _MODE_WAIT_ON.
+  static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
+  //! This is a transitional state which can not be commanded. The switch has
+  //! been commanded off and the handler waits for it to be off.
+  //! When the switch is off, the mode changes to @c MODE_OFF.
+  static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
+  //! This is a transitional state which can not be commanded. The switch
+  //! has been commanded on and the handler waits for it to be on.
+  //! When the switch is on, the mode changes to @c _MODE_TO_ON.
+  static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
+  //! This is a transitional state which can not be commanded. The switch has
+  //! been commanded off and is off now. This state is only to do an RMAP
+  //! cycle once more where the doSendRead() function will set the mode to
+  //! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
+  static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;
+
  void setHkDestination(object_id_t hkDestination);

  /**
@ -467,14 +510,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 returnvalue::OK when the command was successfully inserted,
   *          - @c returnvalue::FAILED else.
   */
@ -659,12 +702,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  virtual void debugInterface(uint8_t positionTracker = 0, object_id_t objectId = 0,
                              uint32_t parameter = 0);

-  /**
-   * @brief Can be overwritten by a child to specify the initial submode when device has been set
-   *        to startup immediately.
-   */
-  virtual Submode_t getInitialSubmode();
-
 protected:
  static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_BASE;

@ -694,15 +731,18 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  size_t rawPacketLen = 0;

  /**
-   * The mode the device handler is currently in.
-   * This should never be changed directly but only with setMode()
+   * Get the current mode
+   *
+   * set via setMode()
   */
-  Mode_t mode;
+  Mode_t getMode();
+
  /**
-   * The submode the device handler is currently in.
-   * This should never be changed directly but only with setMode()
+   * Get the current Submode
+   *
+   * set via setMode()
   */
-  Submode_t submode;
+  Submode_t getSubmode;

  /** This is the counter value from performOperation(). */
  uint8_t pstStep = 0;
@ -783,18 +823,11 @@ 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;
-    //! 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.
+    //! The currently remaining cycles the handler should wait for a reply,
+    //! 0 means there is no reply 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
@ -850,7 +883,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  /** Pointer to the used FDIR instance. If not provided by child,
   * default class is instantiated. */
  FailureIsolationBase *fdirInstance;
-  object_id_t parent = objects::NO_OBJECT;

  //! To correctly delete the default instance.
  bool defaultFDIRUsed;
@ -891,8 +923,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   * Do the transition to the main modes (MODE_ON, MODE_NORMAL and MODE_RAW).
   *
   * If the transition is complete, the mode should be set to the target mode,
-   * which can be deduced from the current mode which is
-   * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]
+   * which can be deduced from the current mode (which is
+   * [_MODE_TO_ON, _MODE_TO_NORMAL, _MODE_TO_RAW]) using getBaseMode()
   *
   * The intended target submode is already set.
   * The origin submode can be read in subModeFrom.
@ -1070,8 +1102,23 @@ class DeviceHandlerBase : public DeviceHandlerIF,

  bool isAwaitingReply();

+  /**
+   * Wrapper function for @handleDeviceTm which wraps the raw buffer with @SerialBufferAdapter.
+   * For interpreted data, prefer the other function.
+   * @param rawData
+   * @param rawDataLen
+   * @param replyId
+   * @param forceDirectTm
+   */
  void handleDeviceTm(const uint8_t *rawData, size_t rawDataLen, DeviceCommandId_t replyId,
                      bool forceDirectTm = false);
+  /**
+   * Can be used to handle Service 8 data replies. This will also generate the TM wiretapping
+   * packets accordingly.
+   * @param dataSet
+   * @param replyId
+   * @param forceDirectTm
+   */
  void handleDeviceTm(const SerializeIF &dataSet, DeviceCommandId_t replyId,
                      bool forceDirectTm = false);

@ -1173,6 +1220,18 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   */
  uint32_t childTransitionDelay;

+  /**
+   * The mode the device handler is currently in.
+   * This should not be changed directly but only with setMode()
+   */
+  Mode_t mode;
+
+  /**
+   * The submode the device handler is currently in.
+   * This should not be changed directly but only with setMode()
+   */
+  Submode_t submode;
+
  /**
   * @brief   The mode the current transition originated from
   *
@ -1190,6 +1249,15 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   */
  Submode_t transitionSourceSubMode;

+  /**
+   * used to make the state machine continue from ON to NOMAL when
+   * a Device is commanded to NORMAL in OFF mode
+   *
+   * set in startTransition()
+   * evaluated in setMode() to continue to NORMAL when ON is reached
+   */
+  bool continueToNormal;
+
  /**
   * read the command queue
   */
@ -1326,11 +1394,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
  void printWarningOrError(sif::OutputTypes errorType, const char *functionName,
                           ReturnValue_t errorCode = returnvalue::FAILED,
                           const char *errorPrint = nullptr);
-
-  /**
-   * @brief Disables all commands and replies when device is set to MODE_OFF
-   */
-  void disableCommandsAndReplies();
 };

 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
--- a/src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerFailureIsolation.cpp
@ -29,7 +29,6 @@ ReturnValue_t DeviceHandlerFailureIsolation::eventReceived(EventMessage* event)
  switch (event->getEvent()) {
    case HasModesIF::MODE_TRANSITION_FAILED:
    case HasModesIF::OBJECT_IN_INVALID_MODE:
-    case DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT:
      // We'll try a recovery as long as defined in MAX_REBOOT.
      // Might cause some AssemblyBase cycles, so keep number low.
      handleRecovery(event->getEvent());
--- a/src/fsfw/devicehandlers/DeviceHandlerIF.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerIF.h
@ -24,9 +24,6 @@ class DeviceHandlerIF {
  static const DeviceCommandId_t RAW_COMMAND_ID = -1;
  static const DeviceCommandId_t NO_COMMAND_ID = -2;

-  static constexpr uint8_t TRANSITION_MODE_CHILD_ACTION_MASK = 0x20;
-  static constexpr uint8_t TRANSITION_MODE_BASE_ACTION_MASK = 0x10;
-
  using dh_heater_request_t = uint8_t;
  using dh_thermal_state_t = int8_t;

@ -54,47 +51,6 @@ class DeviceHandlerIF {
  //! device still is powered. In this mode, only a mode change to @c MODE_OFF
  //! can be commanded, which tries to switch off the device again.
  static const Mode_t MODE_ERROR_ON = 4;
-  //! This is a transitional state which can not be commanded. The device
-  //! handler performs all commands to get the device in a state ready to
-  //! perform commands. When this is completed, the mode changes to @c MODE_ON.
-  static const Mode_t _MODE_START_UP = TRANSITION_MODE_CHILD_ACTION_MASK | 5;
-  //! This is a transitional state which can not be commanded.
-  //! The device handler performs all actions and commands to get the device
-  //! shut down. When the device is off, the mode changes to @c MODE_OFF.
-  //! It is possible to set the mode to _MODE_SHUT_DOWN to use the to off
-  //! transition if available.
-  static const Mode_t _MODE_SHUT_DOWN = TRANSITION_MODE_CHILD_ACTION_MASK | 6;
-  //! It is possible to set the mode to _MODE_TO_ON to use the to on
-  //! transition if available.
-  static const Mode_t _MODE_TO_ON = TRANSITION_MODE_CHILD_ACTION_MASK | HasModesIF::MODE_ON;
-  //! It is possible to set the mode to _MODE_TO_RAW to use the to raw
-  //! transition if available.
-  static const Mode_t _MODE_TO_RAW = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_RAW;
-  //! It is possible to set the mode to _MODE_TO_NORMAL to use the to normal
-  //! transition if available.
-  static const Mode_t _MODE_TO_NORMAL = TRANSITION_MODE_CHILD_ACTION_MASK | MODE_NORMAL;
-  //! This is a transitional state which can not be commanded.
-  //! The device is shut down and ready to be switched off.
-  //! After the command to set the switch off has been sent,
-  //! the mode changes to @c MODE_WAIT_OFF
-  static const Mode_t _MODE_POWER_DOWN = TRANSITION_MODE_BASE_ACTION_MASK | 1;
-  //! This is a transitional state which can not be commanded. The device
-  //! will be switched on in this state. After the command to set the switch
-  //! on has been sent, the mode changes to @c MODE_WAIT_ON.
-  static const Mode_t _MODE_POWER_ON = TRANSITION_MODE_BASE_ACTION_MASK | 2;
-  //! This is a transitional state which can not be commanded. The switch has
-  //! been commanded off and the handler waits for it to be off.
-  //! When the switch is off, the mode changes to @c MODE_OFF.
-  static const Mode_t _MODE_WAIT_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 3;
-  //! This is a transitional state which can not be commanded. The switch
-  //! has been commanded on and the handler waits for it to be on.
-  //! When the switch is on, the mode changes to @c MODE_TO_ON.
-  static const Mode_t _MODE_WAIT_ON = TRANSITION_MODE_BASE_ACTION_MASK | 4;
-  //! This is a transitional state which can not be commanded. The switch has
-  //! been commanded off and is off now. This state is only to do an RMAP
-  //! cycle once more where the doSendRead() function will set the mode to
-  //! MODE_OFF. The reason to do this is to get rid of stuck packets in the IO Board.
-  static const Mode_t _MODE_SWITCH_IS_OFF = TRANSITION_MODE_BASE_ACTION_MASK | 5;

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CDH;
  static const Event DEVICE_BUILDING_COMMAND_FAILED = MAKE_EVENT(0, severity::LOW);
@ -109,7 +65,6 @@ class DeviceHandlerIF {
  static const Event INVALID_DEVICE_COMMAND = MAKE_EVENT(8, severity::LOW);
  static const Event MONITORING_LIMIT_EXCEEDED = MAKE_EVENT(9, severity::LOW);
  static const Event MONITORING_AMBIGUOUS = MAKE_EVENT(10, severity::HIGH);
-  static const Event DEVICE_WANTS_HARD_REBOOT = MAKE_EVENT(11, severity::HIGH);

  static const uint8_t INTERFACE_ID = CLASS_ID::DEVICE_HANDLER_IF;

--- a/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h
+++ b/src/fsfw/devicehandlers/DeviceTmReportingWrapper.h
@ -1,10 +1,9 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_
 #define FSFW_DEVICEHANDLERS_DEVICETMREPORTINGWRAPPER_H_

-#include "fsfw/action/HasActionsIF.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/serialize/SerializeIF.h"
-#include "fsfw/util/dataWrapper.h"
+#include "../action/HasActionsIF.h"
+#include "../objectmanager/SystemObjectIF.h"
+#include "../serialize/SerializeIF.h"

 class DeviceTmReportingWrapper : public SerializeIF {
 public:
--- a/src/fsfw/devicehandlers/HealthDevice.cpp
+++ b/src/fsfw/devicehandlers/HealthDevice.cpp
@ -8,9 +8,7 @@ HealthDevice::HealthDevice(object_id_t setObjectId, MessageQueueId_t parentQueue
      parentQueue(parentQueue),
      commandQueue(),
      healthHelper(this, setObjectId) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue(3);
 }

 HealthDevice::~HealthDevice() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }
--- a/src/fsfw/events/Event.h
+++ b/src/fsfw/events/Event.h
@ -4,8 +4,6 @@
 #include <stdint.h>

 #include "fwSubsystemIdRanges.h"
-// could be moved to more suitable location
-#include <events/subsystemIdRanges.h>

 using EventId_t = uint16_t;
 using EventSeverity_t = uint8_t;
--- a/src/fsfw/events/EventManager.cpp
+++ b/src/fsfw/events/EventManager.cpp
@ -18,9 +18,8 @@ const LocalPool::LocalPoolConfig EventManager::poolConfig = {
 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(
-      MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventReportQueue = QueueFactory::instance()->createMessageQueue(MAX_EVENTS_PER_CYCLE,
+                                                                  EventMessage::EVENT_MESSAGE_SIZE);
 }

 EventManager::~EventManager() {
@ -47,20 +46,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();
@ -206,19 +194,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
@ -43,7 +43,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/fdir/FailureIsolationBase.cpp
+++ b/src/fsfw/fdir/FailureIsolationBase.cpp
@ -9,9 +9,8 @@
 FailureIsolationBase::FailureIsolationBase(object_id_t owner, object_id_t parent,
                                           uint8_t messageDepth, uint8_t parameterDomainBase)
    : ownerId(owner), faultTreeParent(parent), parameterDomainBase(parameterDomainBase) {
-  auto mqArgs = MqArgs(owner, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageDepth, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(messageDepth, EventMessage::EVENT_MESSAGE_SIZE);
 }

 FailureIsolationBase::~FailureIsolationBase() {
@ -62,12 +61,11 @@ ReturnValue_t FailureIsolationBase::initialize() {
        ObjectManager::instance()->get<ConfirmsFailuresIF>(faultTreeParent);
    if (parentIF == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "FailureIsolationBase::intialize: Parent object "
-                 << "invalid" << std::endl;
-      sif::error << "Make sure it implements ConfirmsFailuresIF" << std::endl;
-#else
-      sif::printError("FailureIsolationBase::intialize: Parent object invalid\n");
-      sif::printError("Make sure it implements ConfirmsFailuresIF\n");
+      sif::error << "FailureIsolationBase::intialize: Parent object"
+                 << "invalid." << std::endl;
+#endif
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "Make sure it implements ConfirmsFailuresIF." << std::endl;
 #endif
      return ObjectManagerIF::CHILD_INIT_FAILED;
      return returnvalue::FAILED;
--- a/src/fsfw/fdir/FailureIsolationBase.h
+++ b/src/fsfw/fdir/FailureIsolationBase.h
@ -12,12 +12,13 @@
 class FailureIsolationBase : public ConfirmsFailuresIF, public HasParametersIF {
 public:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FDIR_1;
-  //! FDIR has an internal state, which changed from par2 (oldState) to par1 (newState).
-  static const Event FDIR_CHANGED_STATE = MAKE_EVENT(1, severity::INFO);
-  //! FDIR tries to restart device. Par1: event that caused recovery.
-  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(2, severity::MEDIUM);
-  //! FDIR turns off device. Par1: event that caused recovery.
-  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(3, severity::MEDIUM);
+  static const Event FDIR_CHANGED_STATE =
+      MAKE_EVENT(1, severity::INFO);  //!< FDIR has an internal state, which changed from par2
+                                      //!< (oldState) to par1 (newState).
+  static const Event FDIR_STARTS_RECOVERY = MAKE_EVENT(
+      2, severity::MEDIUM);  //!< FDIR tries to restart device. Par1: event that caused recovery.
+  static const Event FDIR_TURNS_OFF_DEVICE = MAKE_EVENT(
+      3, severity::MEDIUM);  //!< FDIR turns off device. Par1: event that caused recovery.

  FailureIsolationBase(object_id_t owner, object_id_t parent = objects::NO_OBJECT,
                       uint8_t messageDepth = 10, uint8_t parameterDomainBase = 0xF0);
--- a/src/fsfw/globalfunctions/CMakeLists.txt
+++ b/src/fsfw/globalfunctions/CMakeLists.txt
@ -4,7 +4,6 @@ target_sources(
          AsciiConverter.cpp
          CRC.cpp
          DleEncoder.cpp
-          DleParser.cpp
          PeriodicOperationDivider.cpp
          timevalOperations.cpp
          Type.cpp
--- a/src/fsfw/globalfunctions/DleParser.cpp
+++ b/src/fsfw/globalfunctions/DleParser.cpp
@ -1,230 +0,0 @@
-#include "DleParser.h"
-
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-#include <cstdio>
-
-DleParser::DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-                     BufPair decodedBuf, UserHandler handler, void* args)
-    : decodeRingBuf(decodeRingBuf),
-      decoder(decoder),
-      encodedBuf(encodedBuf),
-      decodedBuf(decodedBuf),
-      handler(handler),
-      ctx(args) {
-  if (handler == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "DleParser::DleParser: Invalid user handler" << std::endl;
-#else
-    sif::printError("DleParser::DleParser: Invalid user handler\n");
-#endif
-  }
-}
-
-ReturnValue_t DleParser::passData(uint8_t* data, size_t len) {
-  if (data == nullptr or len == 0 or handler == nullptr) {
-    return returnvalue::FAILED;
-  }
-  size_t copyIntoRingBufFromHere = 0;
-  size_t copyAmount = len;
-  size_t startIdx = 0;
-  ReturnValue_t result = returnvalue::OK;
-  bool startFoundInThisPacket = false;
-  for (size_t idx = 0; idx < len; idx++) {
-    if (data[idx] == DleEncoder::STX_CHAR) {
-      if (not startFound and not startFoundInThisPacket) {
-        startIdx = idx;
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      } else {
-        // Maybe print warning, should not happen
-        decodeRingBuf.clear();
-        ErrorInfo info;
-        info.len = idx;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_STX_CHARS, info);
-        handler(ctx);
-        copyIntoRingBufFromHere = idx;
-        copyAmount = len - idx;
-      }
-      startFound = true;
-      startFoundInThisPacket = true;
-    } else if (data[idx] == DleEncoder::ETX_CHAR) {
-      if (startFoundInThisPacket) {
-        size_t readLen = 0;
-        size_t decodedLen = 0;
-        result = decoder.decode(data + startIdx, idx + 1 - startIdx, &readLen, decodedBuf.first,
-                                decodedBuf.second, &decodedLen);
-        if (result == returnvalue::OK) {
-          ctx.setType(ContextType::PACKET_FOUND);
-          ctx.decodedPacket.first = decodedBuf.first;
-          ctx.decodedPacket.second = decodedLen;
-          this->handler(ctx);
-        } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        } else {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-          handler(ctx);
-        }
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      } else if (startFound) {
-        // ETX found but STX was found in another mini packet. Reconstruct the full packet
-        // to decode it
-        result = decodeRingBuf.writeData(data, idx + 1);
-        if (result != returnvalue::OK) {
-          ErrorInfo info;
-          info.res = result;
-          prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-          handler(ctx);
-        }
-        size_t fullEncodedLen = decodeRingBuf.getAvailableReadData();
-        if (fullEncodedLen > encodedBuf.second) {
-          ErrorInfo info;
-          info.len = fullEncodedLen;
-          prepareErrorContext(ErrorTypes::ENCODED_BUF_TOO_SMALL, info);
-          handler(ctx);
-          decodeRingBuf.clear();
-        } else {
-          size_t decodedLen = 0;
-          size_t readLen = 0;
-          decodeRingBuf.readData(encodedBuf.first, fullEncodedLen, true);
-          result = decoder.decode(encodedBuf.first, fullEncodedLen, &readLen, decodedBuf.first,
-                                  decodedBuf.second, &decodedLen);
-          if (result == returnvalue::OK) {
-            if (this->handler != nullptr) {
-              ctx.setType(ContextType::PACKET_FOUND);
-              ctx.decodedPacket.first = decodedBuf.first;
-              ctx.decodedPacket.second = decodedLen;
-              this->handler(ctx);
-            }
-          } else if (result == DleEncoder::STREAM_TOO_SHORT) {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODING_BUF_TOO_SMALL, info);
-            handler(ctx);
-          } else {
-            ErrorInfo info;
-            info.res = result;
-            prepareErrorContext(ErrorTypes::DECODE_ERROR, info);
-            handler(ctx);
-          }
-          decodeRingBuf.clear();
-          startFound = false;
-          startFoundInThisPacket = false;
-          if ((idx + 1) < len) {
-            copyIntoRingBufFromHere = idx + 1;
-            copyAmount = len - idx - 1;
-          } else {
-            copyAmount = 0;
-          }
-        }
-      } else {
-        // End data without preceeding STX
-        ErrorInfo info;
-        info.len = idx + 1;
-        prepareErrorContext(ErrorTypes::CONSECUTIVE_ETX_CHARS, info);
-        handler(ctx);
-        decodeRingBuf.clear();
-        if ((idx + 1) < len) {
-          copyIntoRingBufFromHere = idx + 1;
-          copyAmount = len - idx - 1;
-        } else {
-          copyAmount = 0;
-        }
-      }
-      startFoundInThisPacket = false;
-      startFound = false;
-    }
-  }
-  if (copyAmount > 0) {
-    result = decodeRingBuf.writeData(data + copyIntoRingBufFromHere, copyAmount);
-    if (result != returnvalue::OK) {
-      ErrorInfo info;
-      info.res = result;
-      prepareErrorContext(ErrorTypes::RING_BUF_ERROR, info);
-      handler(ctx);
-    }
-  }
-  return returnvalue::OK;
-}
-
-void DleParser::defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleFoundPacket: Detected DLE packet with " << len << " bytes"
-            << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleFoundPacket: Detected DLE packet with %d bytes\n", len);
-#endif
-#endif
-}
-
-void DleParser::defaultErrorHandler(ErrorTypes err, ErrorInfo ctx) {
-  switch (err) {
-    case (ErrorTypes::NONE): {
-      errorPrinter("No error");
-      break;
-    }
-    case (ErrorTypes::DECODE_ERROR): {
-      errorPrinter("Decode Error");
-      break;
-    }
-    case (ErrorTypes::RING_BUF_ERROR): {
-      errorPrinter("Ring Buffer Error");
-      break;
-    }
-    case (ErrorTypes::ENCODED_BUF_TOO_SMALL):
-    case (ErrorTypes::DECODING_BUF_TOO_SMALL): {
-      char opt[64];
-      snprintf(opt, sizeof(opt), ": Too small for packet with length %zu", ctx.len);
-      if (err == ErrorTypes::ENCODED_BUF_TOO_SMALL) {
-        errorPrinter("Encoded buf too small", opt);
-      } else {
-        errorPrinter("Decoding buf too small", opt);
-      }
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_STX_CHARS): {
-      errorPrinter("Consecutive STX chars detected");
-      break;
-    }
-    case (ErrorTypes::CONSECUTIVE_ETX_CHARS): {
-      errorPrinter("Consecutive ETX chars detected");
-      break;
-    }
-  }
-}
-
-void DleParser::errorPrinter(const char* str, const char* opt) {
-  if (opt == nullptr) {
-    opt = "";
-  }
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "DleParserBase::handleParseError: " << str << opt << std::endl;
-#else
-  sif::printInfo("DleParserBase::handleParseError: %s%s\n", str, opt);
-#endif
-#endif
-}
-
-void DleParser::prepareErrorContext(ErrorTypes err, ErrorInfo info) {
-  ctx.setType(ContextType::ERROR);
-  ctx.error.first = err;
-  ctx.error.second = info;
-}
-
-void DleParser::reset() {
-  startFound = false;
-  decodeRingBuf.clear();
-}
--- a/src/fsfw/globalfunctions/DleParser.h
+++ b/src/fsfw/globalfunctions/DleParser.h
@ -1,125 +0,0 @@
-#pragma once
-
-#include <fsfw/container/SimpleRingBuffer.h>
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <fsfw/returnvalues/returnvalue.h>
-
-#include <cstddef>
-#include <utility>
-
-/**
- * @brief This base helper class can be used to extract DLE encoded packets from a data stream
- * @details
- * The core API of the parser takes received packets which can contains DLE packets. The parser
- * can deal with DLE packets split across multiple packets. It does so by using a dedicated
- * decoding ring buffer. The user can process received packets and detect errors by
- * overriding two provided virtual methods. This also allows detecting multiple DLE packets
- * inside one passed packet.
- */
-class DleParser {
- public:
-  using BufPair = std::pair<uint8_t*, size_t>;
-
-  enum class ContextType { PACKET_FOUND, ERROR };
-
-  enum class ErrorTypes {
-    NONE,
-    ENCODED_BUF_TOO_SMALL,
-    DECODING_BUF_TOO_SMALL,
-    DECODE_ERROR,
-    RING_BUF_ERROR,
-    CONSECUTIVE_STX_CHARS,
-    CONSECUTIVE_ETX_CHARS
-  };
-
-  union ErrorInfo {
-    size_t len;
-    ReturnValue_t res;
-  };
-
-  using ErrorPair = std::pair<ErrorTypes, ErrorInfo>;
-
-  struct Context {
-   public:
-    Context(void* args) : userArgs(args) { setType(ContextType::PACKET_FOUND); }
-
-    void setType(ContextType type) {
-      this->type = type;
-      if (type == ContextType::PACKET_FOUND) {
-        error.first = ErrorTypes::NONE;
-        error.second.len = 0;
-      } else {
-        decodedPacket.first = nullptr;
-        decodedPacket.second = 0;
-      }
-    }
-
-    ContextType getType() const { return type; }
-
-    BufPair decodedPacket = {};
-    ErrorPair error;
-    void* userArgs;
-
-   private:
-    ContextType type;
-  };
-
-  using UserHandler = void (*)(const Context& ctx);
-
-  /**
-   * Base class constructor
-   * @param decodeRingBuf Ring buffer used to store multiple packets to allow detecting DLE packets
-   * split across multiple packets
-   * @param decoder Decoder instance
-   * @param encodedBuf Buffer used to store encoded packets. It has to be large enough to hold
-   * the largest expected encoded DLE packet size
-   * @param decodedBuf Buffer used to store decoded packets. It has to be large enough to hold the
-   * largest expected decoded DLE packet size
-   * @param handler Function which will be called on a found packet
-   * @param args Arbitrary user argument
-   */
-  DleParser(SimpleRingBuffer& decodeRingBuf, DleEncoder& decoder, BufPair encodedBuf,
-            BufPair decodedBuf, UserHandler handler, void* args);
-
-  /**
-   * This function allows to pass new data into the parser. It then scans for DLE packets
-   * automatically and inserts (part of) the packet into a ring buffer if necessary.
-   * @param data
-   * @param len
-   * @return
-   */
-  ReturnValue_t passData(uint8_t* data, size_t len);
-
-  /**
-   * Example found packet handler
-   * function call
-   * @param packet Decoded packet
-   * @param len Length of detected packet
-   */
-  void defaultFoundPacketHandler(uint8_t* packet, size_t len, void* args);
-  /**
-   * Will be called if an error occured in the #passData call
-   * @param err
-   * @param ctx Context information depending on the error type
-   *  - For buffer length errors, will be set to the detected packet length which is too large
-   *  - For decode or ring buffer errors, will be set to the result returned from the failed call
-   */
-  static void defaultErrorHandler(ErrorTypes err, ErrorInfo ctx);
-
-  static void errorPrinter(const char* str, const char* opt = nullptr);
-
-  void prepareErrorContext(ErrorTypes err, ErrorInfo ctx);
-  /**
-   * Resets the parser by resetting the internal states and clearing the decoding ring buffer
-   */
-  void reset();
-
- private:
-  SimpleRingBuffer& decodeRingBuf;
-  DleEncoder& decoder;
-  BufPair encodedBuf;
-  BufPair decodedBuf;
-  UserHandler handler = nullptr;
-  Context ctx;
-  bool startFound = false;
-};
--- a/src/fsfw/health/HasHealthIF.h
+++ b/src/fsfw/health/HasHealthIF.h
@ -16,24 +16,26 @@ class HasHealthIF {
  };

  static const uint8_t INTERFACE_ID = CLASS_ID::HAS_HEALTH_IF;
-  static constexpr ReturnValue_t OBJECT_NOT_HEALTHY = returnvalue::makeCode(INTERFACE_ID, 1);
-  static constexpr ReturnValue_t INVALID_HEALTH_STATE = returnvalue::makeCode(INTERFACE_ID, 2);
-  static constexpr ReturnValue_t IS_EXTERNALLY_CONTROLLED = returnvalue::makeCode(INTERFACE_ID, 3);
+  static const ReturnValue_t OBJECT_NOT_HEALTHY = MAKE_RETURN_CODE(1);
+  static const ReturnValue_t INVALID_HEALTH_STATE = MAKE_RETURN_CODE(2);

  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);
-  //! 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). 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.
-  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
+  static const Event OVERWRITING_HEALTH =
+      MAKE_EVENT(9, severity::LOW);  //!< Assembly overwrites health information of children to keep
+                                     //!< satellite alive.
+  static const Event TRYING_RECOVERY =
+      MAKE_EVENT(10, severity::MEDIUM);  //!< Someone starts a recovery of a component (typically
+                                         //!< power-cycle). No parameters.
+  static const Event RECOVERY_STEP =
+      MAKE_EVENT(11, 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_DONE = MAKE_EVENT(
+      12,
+      severity::MEDIUM);  //!< Recovery was completed. Not necessarily successful. No parameters.
+
  virtual ~HasHealthIF() {}

  virtual MessageQueueId_t getCommandQueue() const = 0;
--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/src/fsfw/internalerror/InternalErrorReporter.cpp
@ -7,13 +7,11 @@

 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth)
    : SystemObject(setObjectId),
+      commandQueue(QueueFactory::instance()->createMessageQueue(messageQueueDepth)),
      poolManager(this, commandQueue),
      internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
      internalErrorDataset(this) {
  mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }

 InternalErrorReporter::~InternalErrorReporter() { MutexFactory::instance()->deleteMutex(mutex); }
@ -38,14 +36,15 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
    if ((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::debug << "InternalErrorReporter::performOperation: Errors "
-                 << "occured: Queue | TM | Store : " << newQueueHits << " | " << newTmHits << " | "
-                 << newStoreHits << std::endl;
+                 << "occured!" << std::endl;
+      sif::debug << "Queue errors: " << newQueueHits << std::endl;
+      sif::debug << "TM errors: " << newTmHits << std::endl;
+      sif::debug << "Store errors: " << newStoreHits << std::endl;
 #else
-      sif::printDebug(
-          "InternalErrorReporter::performOperation: Errors occured: Queue | TM | Store: %lu | %lu "
-          "| %lu\n",
-          static_cast<unsigned int>(newQueueHits), static_cast<unsigned int>(newTmHits),
-          static_cast<unsigned int>(newStoreHits));
+      sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+      sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+      sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+      sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
 #endif
    }
  }
--- a/src/fsfw/ipc/CommandMessageIF.h
+++ b/src/fsfw/ipc/CommandMessageIF.h
@ -34,7 +34,7 @@ class CommandMessageIF {
  static const Command_t CMD_NONE = MAKE_COMMAND_ID(0);
  static const Command_t REPLY_COMMAND_OK = MAKE_COMMAND_ID(1);
  //! Reply indicating that the current command was rejected,
-  //! Parameter 1 should contain the error code
+  //! par1 should contain the error code
  static const Command_t REPLY_REJECTED = MAKE_COMMAND_ID(2);

  virtual ~CommandMessageIF(){};
--- a/src/fsfw/modes/HasModesIF.h
+++ b/src/fsfw/modes/HasModesIF.h
@ -19,33 +19,32 @@ class HasModesIF {
  static const ReturnValue_t INVALID_SUBMODE = MAKE_RETURN_CODE(0x04);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SYSTEM_MANAGER;
-  //! An object announces changing the mode. p1: target mode. p2: target submode
-  static const Event CHANGING_MODE = MAKE_EVENT(0, severity::INFO);
-  //! An Object announces its mode; parameter1 is mode, parameter2 is submode
-  static const Event MODE_INFO = MAKE_EVENT(1, severity::INFO);
+  static const Event CHANGING_MODE =
+      MAKE_EVENT(0, severity::INFO);  //!< An object announces changing the mode. p1: target mode.
+                                      //!< p2: target submode
+  static const Event MODE_INFO = MAKE_EVENT(
+      1,
+      severity::INFO);  //!< An Object announces its mode; parameter1 is mode, parameter2 is submode
  static const Event FALLBACK_FAILED = MAKE_EVENT(2, severity::HIGH);
  static const Event MODE_TRANSITION_FAILED = MAKE_EVENT(3, severity::LOW);
  static const Event CANT_KEEP_MODE = MAKE_EVENT(4, severity::HIGH);
-  //! Indicates a bug or configuration failure: Object is in a mode it should never be in.
-  static const Event OBJECT_IN_INVALID_MODE = MAKE_EVENT(5, severity::LOW);
-  //! The mode is changed, but for some reason, the change is forced, i.e. EXTERNAL_CONTROL ignored.
-  //! p1: target mode. p2: target submode
-  static const Event FORCING_MODE = MAKE_EVENT(6, severity::MEDIUM);
-  //! A mode command was rejected by the called object. Par1: called object id, Par2: return code.
-  static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
+  static const Event OBJECT_IN_INVALID_MODE =
+      MAKE_EVENT(5, severity::LOW);  //!< Indicates a bug or configuration failure: Object is in a
+                                     //!< mode it should never be in.
+  static const Event FORCING_MODE = MAKE_EVENT(
+      6, severity::MEDIUM);  //!< The mode is changed, but for some reason, the change is forced,
+                             //!< i.e. EXTERNAL_CONTROL ignored. p1: target mode. p2: target submode
+  static const Event MODE_CMD_REJECTED =
+      MAKE_EVENT(7, severity::LOW);  //!< A mode command was rejected by the called object. Par1:
+                                     //!< called object id, Par2: return code.

-  //! The device is powered and ready to perform operations. In this mode, no commands are
-  //! sent by the device handler itself, but direct commands van be commanded and will be
-  //! interpreted
-  static constexpr Mode_t MODE_ON = 1;
-  //! The device is powered off. The only command accepted in this mode is a mode change to on.
-  static constexpr Mode_t MODE_OFF = 0;
-
-  static constexpr Mode_t MODE_INVALID = -1;
-  static constexpr Mode_t MODE_UNDEFINED = -2;
-
-  //! To avoid checks against magic number "0".
-  static const Submode_t SUBMODE_NONE = 0;
+  static const Mode_t MODE_ON =
+      1;  //!< The device is powered and ready to perform operations. In this mode, no commands are
+          //!< sent by the device handler itself, but direct commands van be commanded and will be
+          //!< interpreted
+  static const Mode_t MODE_OFF = 0;  //!< The device is powered off. The only command accepted in
+                                     //!< this mode is a mode change to on.
+  static const Submode_t SUBMODE_NONE = 0;  //!< To avoid checks against magic number "0".

  virtual ~HasModesIF() {}
  virtual MessageQueueId_t getCommandQueue() const = 0;
--- a/src/fsfw/monitoring/MonitoringMessageContent.h
+++ b/src/fsfw/monitoring/MonitoringMessageContent.h
@ -8,7 +8,7 @@
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../serialize/SerializeElement.h"
 #include "../serviceinterface/ServiceInterface.h"
-#include "../timemanager/TimeStamperIF.h"
+#include "../timemanager/TimeWriterIF.h"
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
 #include "monitoringConf.h"
@ -34,9 +34,9 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
  SerializeElement<T> limitValue;
  SerializeElement<ReturnValue_t> oldState;
  SerializeElement<ReturnValue_t> newState;
-  uint8_t rawTimestamp[TimeStamperIF::MAXIMUM_TIMESTAMP_LEN] = {};
+  uint8_t rawTimestamp[TimeWriterIF::MAXIMUM_TIMESTAMP_LEN] = {};
  SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
-  TimeStamperIF* timeStamper;
+  TimeWriterIF* timeStamper;
  MonitoringReportContent()
      : SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
        monitorId(0),
@ -79,7 +79,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
  }
  bool checkAndSetStamper() {
    if (timeStamper == nullptr) {
-      timeStamper = ObjectManager::instance()->get<TimeStamperIF>(timeStamperId);
+      timeStamper = ObjectManager::instance()->get<TimeWriterIF>(timeStamperId);
      if (timeStamper == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
        sif::error << "MonitoringReportContent::checkAndSetStamper: "
--- a/src/fsfw/objectmanager/ObjectManager.cpp
+++ b/src/fsfw/objectmanager/ObjectManager.cpp
@ -95,16 +95,13 @@ void ObjectManager::initialize() {
  for (auto const& it : objectList) {
    result = it.second->initialize();
    if (result != returnvalue::OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
+      object_id_t var = it.first;
      sif::error << "ObjectManager::initialize: Object 0x" << std::hex << std::setw(8)
-                 << std::setfill('0') << it.first << " failed to initialize with code 0x" << result
-                 << std::dec << std::setfill(' ') << std::endl;
-#else
-      sif::printError(
-          "ObjectManager::initialize: Object 0x%08x failed to initialize with code 0x%04x\n", var,
-          it.first);
-#endif
+                 << std::setfill('0') << var
+                 << " failed to "
+                    "initialize with code 0x"
+                 << result << std::dec << std::setfill(' ') << std::endl;
 #endif
      errorCount++;
    }
--- a/src/fsfw/osal/CMakeLists.txt
+++ b/src/fsfw/osal/CMakeLists.txt
@ -16,9 +16,7 @@ elseif(FSFW_OSAL MATCHES "host")

 else()

-  message(
-    WARNING
-      "${MSG_PREFIX} The FSFW_OSAL variable was not set. Assuming host OS..")
+  message(WARNING "The OS_FSFW variable was not set. Assuming host OS..")
  # Not set. Assumuing this is a host build, try to determine host OS
  if(WIN32)
    add_subdirectory(host)
--- a/src/fsfw/osal/common/TcpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/TcpTmTcBridge.cpp
@ -18,7 +18,7 @@

 TcpTmTcBridge::TcpTmTcBridge(object_id_t objectId, object_id_t tcDestination, object_id_t tmStoreId,
                             object_id_t tcStoreId)
-    : TmTcBridge(objectId, tcDestination, tmStoreId, 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/UdpTmTcBridge.cpp
+++ b/src/fsfw/osal/common/UdpTmTcBridge.cpp
@ -22,7 +22,7 @@ const std::string UdpTmTcBridge::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_POR
 UdpTmTcBridge::UdpTmTcBridge(object_id_t objectId, object_id_t tcDestination,
                             const std::string &udpServerPort_, object_id_t tmStoreId,
                             object_id_t tcStoreId)
-    : TmTcBridge(objectId, tcDestination, tmStoreId, tcStoreId) {
+    : TmTcBridge("UDP TMTC Bridge", objectId, tcDestination, tmStoreId, tcStoreId) {
  if (udpServerPort_.empty()) {
    udpServerPort = DEFAULT_SERVER_PORT;
  } else {
--- a/src/fsfw/parameters/HasParametersIF.h
+++ b/src/fsfw/parameters/HasParametersIF.h
@ -66,8 +66,7 @@ class HasParametersIF {
   * @param newValues
   * @param startAtIndex Linear index, runs left to right, top to bottom for
   * matrix indexes.
-   * @return returnvalue::OK if parameter is valid and a set function of the parameter wrapper was
-   * called.
+   * @return
   */
  virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                                     ParameterWrapper *parameterWrapper,
--- a/src/fsfw/parameters/ParameterWrapper.cpp
+++ b/src/fsfw/parameters/ParameterWrapper.cpp
@ -211,13 +211,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (data == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable or "
-                    "data pointer not set"
-                 << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Called on read-only variable!" << std::endl;
 #else
-    sif::printWarning(
-        "ParameterWrapper::copyFrom: Called on read-only variable "
-        "or data pointer not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Called on read-only variable!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return READONLY;
@ -226,9 +222,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (from->readonlyData == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Source not set" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Source not set!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Source not set\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Source not set!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return SOURCE_NOT_SET;
@ -237,9 +233,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (type != from->type) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Datatype missmatch!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Datatype missmatch!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return DATATYPE_MISSMATCH;
@ -249,9 +245,9 @@ ReturnValue_t ParameterWrapper::copyFrom(const ParameterWrapper *from,
  if (rows == 0 or columns == 0) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero" << std::endl;
+    sif::warning << "ParameterWrapper::copyFrom: Columns or rows zero!" << std::endl;
 #else
-    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero\n");
+    sif::printWarning("ParameterWrapper::copyFrom: Columns or rows zero!\n");
 #endif
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
    return COLUMN_OR_ROWS_ZERO;
--- a/src/fsfw/power/PowerSwitchIF.h
+++ b/src/fsfw/power/PowerSwitchIF.h
@ -29,9 +29,9 @@ class PowerSwitchIF {
  static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
  static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
-  //!< 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 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.
   *
--- a/src/fsfw/pus/CService200ModeCommanding.cpp
+++ b/src/fsfw/pus/CService200ModeCommanding.cpp
@ -10,8 +10,8 @@
 CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId, uint16_t apid,
                                                     uint8_t serviceId, uint8_t numParallelCommands,
                                                     uint16_t commandTimeoutSeconds)
-    : CommandingServiceBase(objectId, apid, serviceId, numParallelCommands, commandTimeoutSeconds) {
-}
+    : CommandingServiceBase(objectId, apid, "PUS 200 Mode MGMT", serviceId, numParallelCommands,
+                            commandTimeoutSeconds) {}

 CService200ModeCommanding::~CService200ModeCommanding() {}

--- a/src/fsfw/pus/CService201HealthCommanding.cpp
+++ b/src/fsfw/pus/CService201HealthCommanding.cpp
@ -10,8 +10,8 @@ CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId, u
                                                         uint8_t serviceId,
                                                         uint8_t numParallelCommands,
                                                         uint16_t commandTimeoutSeconds)
-    : CommandingServiceBase(objectId, apid, serviceId, numParallelCommands, commandTimeoutSeconds) {
-}
+    : CommandingServiceBase(objectId, apid, "PUS 201 Health MGMT", serviceId, numParallelCommands,
+                            commandTimeoutSeconds) {}

 ReturnValue_t CService201HealthCommanding::isValidSubservice(uint8_t subservice) {
  switch (subservice) {
--- a/src/fsfw/pus/Service11TelecommandScheduling.tpp
+++ b/src/fsfw/pus/Service11TelecommandScheduling.tpp
@ -16,7 +16,9 @@ inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduli
    : PusServiceBase(params),
      RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds),
      debugMode(debugMode),
-      tcRecipient(tcRecipient) {}
+      tcRecipient(tcRecipient) {
+  params.name = "PUS 11 TC Scheduling";
+}

 template <size_t MAX_NUM_TCS>
 inline Service11TelecommandScheduling<MAX_NUM_TCS>::~Service11TelecommandScheduling() = default;
@ -75,7 +77,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService
  // NOTE: The iterator is increased in the loop here. Increasing the iterator as for-loop arg
  // does not work in this case as we are deleting the current element here.
  for (auto it = telecommandMap.begin(); it != telecommandMap.end();) {
-    if (it->first <= static_cast<uint32_t>(tNow.tv_sec)) {
+    if (it->first <= tNow.tv_sec) {
      if (schedulingEnabled) {
        // release tc
        TmTcMessage releaseMsg(it->second.storeAddr);
@ -568,11 +570,13 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::getMapFilterFr
        return INVALID_TIME_WINDOW;
      }
      itBegin = telecommandMap.begin();
-      itEnd = telecommandMap.begin();

      while (itBegin->first < fromTimestamp && itBegin != telecommandMap.end()) {
        itBegin++;
      }
+
+      // start looking for end beginning at begin
+      itEnd = itBegin;
      while (itEnd->first <= toTimestamp && itEnd != telecommandMap.end()) {
        itEnd++;
      }
--- a/src/fsfw/pus/Service17Test.cpp
+++ b/src/fsfw/pus/Service17Test.cpp
@ -8,7 +8,9 @@
 Service17Test::Service17Test(PsbParams params)
    : PusServiceBase(params),
      storeHelper(params.apid),
-      tmHelper(params.serviceId, storeHelper, sendHelper) {}
+      tmHelper(params.serviceId, storeHelper, sendHelper) {
+  params.name = "PUS 17 Test";
+}

 Service17Test::~Service17Test() = default;

--- a/src/fsfw/pus/Service1TelecommandVerification.cpp
+++ b/src/fsfw/pus/Service1TelecommandVerification.cpp
@ -11,7 +11,7 @@ Service1TelecommandVerification::Service1TelecommandVerification(object_id_t obj
                                                                 uint16_t apid, uint8_t serviceId,
                                                                 object_id_t targetDestination,
                                                                 uint16_t messageQueueDepth,
-                                                                 TimeStamperIF* timeStamper)
+                                                                 TimeWriterIF* timeStamper)
    : SystemObject(objectId),
      apid(apid),
      serviceId(serviceId),
@ -134,7 +134,7 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
    storeHelper.setTmStore(*tmStore);
  }
  if (timeStamper == nullptr) {
-    timeStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
+    timeStamper = ObjectManager::instance()->get<TimeWriterIF>(objects::TIME_STAMPER);
    if (timeStamper == nullptr) {
      return ObjectManagerIF::CHILD_INIT_FAILED;
    }
--- a/src/fsfw/pus/Service1TelecommandVerification.h
+++ b/src/fsfw/pus/Service1TelecommandVerification.h
@ -47,7 +47,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,

  Service1TelecommandVerification(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                                  object_id_t targetDestination, uint16_t messageQueueDepth,
-                                  TimeStamperIF* timeStamper = nullptr);
+                                  TimeWriterIF* timeStamper = nullptr);
  ~Service1TelecommandVerification() override;

  /**
@ -87,7 +87,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
  TmStoreHelper storeHelper;
  TmStoreAndSendWrapper tmHelper;
  InternalErrorReporterIF* errReporter = nullptr;
-  TimeStamperIF* timeStamper = nullptr;
+  TimeWriterIF* timeStamper = nullptr;
  StorageManagerIF* tmStore = nullptr;
  MessageQueueIF* tmQueue = nullptr;

--- a/src/fsfw/pus/Service20ParameterManagement.cpp
+++ b/src/fsfw/pus/Service20ParameterManagement.cpp
@ -11,8 +11,8 @@ Service20ParameterManagement::Service20ParameterManagement(object_id_t objectId,
                                                           uint8_t serviceId,
                                                           uint8_t numberOfParallelCommands,
                                                           uint16_t commandTimeoutSeconds)
-    : CommandingServiceBase(objectId, apid, serviceId, numberOfParallelCommands,
-                            commandTimeoutSeconds) {}
+    : CommandingServiceBase(objectId, apid, "PUS 20 Parameter MGMT", serviceId,
+                            numberOfParallelCommands, commandTimeoutSeconds) {}

 Service20ParameterManagement::~Service20ParameterManagement() = default;

--- a/src/fsfw/pus/Service2DeviceAccess.cpp
+++ b/src/fsfw/pus/Service2DeviceAccess.cpp
@ -14,8 +14,8 @@
 Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                                           uint8_t numberOfParallelCommands,
                                           uint16_t commandTimeoutSeconds)
-    : CommandingServiceBase(objectId, apid, serviceId, numberOfParallelCommands,
-                            commandTimeoutSeconds) {}
+    : CommandingServiceBase(objectId, apid, "PUS 2 Raw Commanding", serviceId,
+                            numberOfParallelCommands, commandTimeoutSeconds) {}

 Service2DeviceAccess::~Service2DeviceAccess() {}

--- a/src/fsfw/pus/Service3Housekeeping.cpp
+++ b/src/fsfw/pus/Service3Housekeeping.cpp
@ -5,7 +5,7 @@
 #include "fsfw/pus/servicepackets/Service3Packets.h"

 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId)
-    : CommandingServiceBase(objectId, apid, serviceId, NUM_OF_PARALLEL_COMMANDS,
+    : CommandingServiceBase(objectId, apid, "PUS 3 HK", serviceId, NUM_OF_PARALLEL_COMMANDS,
                            COMMAND_TIMEOUT_SECONDS) {}

 Service3Housekeeping::~Service3Housekeeping() {}
@ -208,17 +208,17 @@ ReturnValue_t Service3Housekeeping::handleReply(const CommandMessage* reply,
      ReturnValue_t error = returnvalue::FAILED;
      HousekeepingMessage::getHkRequestFailureReply(reply, &error);
      failureParameter2 = error;
-      return returnvalue::FAILED;
+      return CommandingServiceBase::EXECUTION_COMPLETE;
    }

    default:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::warning << "Service3Housekeeping::handleReply: Invalid reply with "
-                   << "reply command " << command << std::endl;
+                   << "reply command " << command << "!" << std::endl;
 #else
      sif::printWarning(
          "Service3Housekeeping::handleReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
          command);
 #endif
      return CommandingServiceBase::INVALID_REPLY;
@ -248,28 +248,19 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
    case (HousekeepingMessage::HK_REQUEST_FAILURE): {
      break;
    }
-    case (CommandMessage::REPLY_REJECTED): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "Service3Housekeeping::handleUnrequestedReply: Unexpected reply "
-                      "rejected with error code"
-                   << reply->getParameter() << std::endl;
-#else
-#endif
-      break;
-    }

    default: {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
      sif::warning << "Service3Housekeeping::handleUnrequestedReply: Invalid reply with reply "
                      "command "
-                   << command << "" << std::endl;
+                   << command << "!" << std::endl;
 #else
      sif::printWarning(
          "Service3Housekeeping::handleUnrequestedReply: Invalid reply with "
-          "reply command %hu\n",
+          "reply command %hu!\n",
          command);
 #endif
-      break;
+      return;
    }
  }

@ -284,7 +275,6 @@ void Service3Housekeeping::handleUnrequestedReply(CommandMessage* reply) {
        "Could not generate reply!\n");
 #endif
  }
-  CommandingServiceBase::handleUnrequestedReply(reply);
 }

 MessageQueueId_t Service3Housekeeping::getHkQueue() const { return commandQueue->getId(); }
--- a/src/fsfw/pus/Service5EventReporting.cpp
+++ b/src/fsfw/pus/Service5EventReporting.cpp
@ -13,9 +13,8 @@ Service5EventReporting::Service5EventReporting(PsbParams params, size_t maxNumbe
      storeHelper(params.apid),
      tmHelper(params.serviceId, storeHelper, sendHelper),
      maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-  auto mqArgs = MqArgs(getObjectId(), static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  psbParams.name = "PUS 5 Event Reporting";
+  eventQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service5EventReporting::~Service5EventReporting() {
@ -39,6 +38,9 @@ ReturnValue_t Service5EventReporting::performService() {
      }
    }
  }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "Service5EventReporting::generateEventReport: Too many events" << std::endl;
+#endif
  return returnvalue::OK;
 }

--- a/src/fsfw/pus/Service8FunctionManagement.cpp
+++ b/src/fsfw/pus/Service8FunctionManagement.cpp
@ -12,8 +12,8 @@ Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId, uin
                                                       uint8_t serviceId,
                                                       uint8_t numParallelCommands,
                                                       uint16_t commandTimeoutSeconds)
-    : CommandingServiceBase(objectId, apid, serviceId, numParallelCommands, commandTimeoutSeconds) {
-}
+    : CommandingServiceBase(objectId, apid, "PUS 8 Functional Commanding", serviceId,
+                            numParallelCommands, commandTimeoutSeconds) {}

 Service8FunctionManagement::~Service8FunctionManagement() {}

--- a/src/fsfw/pus/Service9TimeManagement.cpp
+++ b/src/fsfw/pus/Service9TimeManagement.cpp
@ -5,7 +5,9 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/timemanager/CCSDSTime.h"

-Service9TimeManagement::Service9TimeManagement(PsbParams params) : PusServiceBase(params) {}
+Service9TimeManagement::Service9TimeManagement(PsbParams params) : PusServiceBase(params) {
+  params.name = "PUS 9 Time MGMT";
+}

 Service9TimeManagement::~Service9TimeManagement() = default;

--- a/src/fsfw/pus/Service9TimeManagement.h
+++ b/src/fsfw/pus/Service9TimeManagement.h
@ -6,10 +6,10 @@
 class Service9TimeManagement : public PusServiceBase {
 public:
  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
-  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
-  static constexpr Event CLOCK_SET = MAKE_EVENT(0, severity::INFO);
-  //!< Clock could not be set. P1: Returncode.
-  static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, severity::LOW);
+  static constexpr Event CLOCK_SET =
+      MAKE_EVENT(0, severity::INFO);  //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+  static constexpr Event CLOCK_SET_FAILURE =
+      MAKE_EVENT(1, severity::LOW);  //!< Clock could not be set. P1: Returncode.

  static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;

--- a/src/fsfw/returnvalues/returnvalue.h
+++ b/src/fsfw/returnvalues/returnvalue.h
@ -1,8 +1,6 @@
 #ifndef FSFW_RETURNVALUES_RETURNVALUE_H_
 #define FSFW_RETURNVALUES_RETURNVALUE_H_

-#include <returnvalues/classIds.h>
-
 #include <cstdint>

 #include "FwClassIds.h"
--- a/src/fsfw/serialize/SerialBufferAdapter.cpp
+++ b/src/fsfw/serialize/SerialBufferAdapter.cpp
@ -21,7 +21,7 @@ SerialBufferAdapter<count_t>::SerialBufferAdapter(uint8_t* buffer, count_t buffe
      bufferLength(bufferLength) {}

 template <typename count_t>
-SerialBufferAdapter<count_t>::~SerialBufferAdapter() {}
+SerialBufferAdapter<count_t>::~SerialBufferAdapter() = default;

 template <typename count_t>
 ReturnValue_t SerialBufferAdapter<count_t>::serialize(uint8_t** buffer, size_t* size,
@ -119,10 +119,10 @@ const uint8_t* SerialBufferAdapter<count_t>::getConstBuffer() const {
 }

 template <typename count_t>
-void SerialBufferAdapter<count_t>::setBuffer(uint8_t* buffer, count_t bufferLength) {
-  this->buffer = buffer;
-  this->constBuffer = buffer;
-  this->bufferLength = bufferLength;
+void SerialBufferAdapter<count_t>::setConstBuffer(const uint8_t* buf, count_t bufLen) {
+  this->buffer = nullptr;
+  this->bufferLength = bufLen;
+  this->constBuffer = buf;
 }

 // forward Template declaration for linker
--- a/src/fsfw/serialize/SerialBufferAdapter.h
+++ b/src/fsfw/serialize/SerialBufferAdapter.h
@ -21,6 +21,7 @@
 template <typename count_t>
 class SerialBufferAdapter : public SerializeIF {
 public:
+  SerialBufferAdapter() = default;
  /**
   * Constructor for constant uint8_t buffer. Length field can be serialized optionally.
   * Type of length can be supplied as template type.
@ -40,12 +41,12 @@ class SerialBufferAdapter : public SerializeIF {
   */
  SerialBufferAdapter(uint8_t* buffer, count_t bufferLength, bool serializeLength = false);

-  virtual ~SerialBufferAdapter();
+  ~SerialBufferAdapter() override;

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

-  virtual size_t getSerializedSize() const override;
+  [[nodiscard]] size_t getSerializedSize() const override;

  /**
   * @brief This function deserializes a buffer into the member buffer.
@ -59,12 +60,12 @@ class SerialBufferAdapter : public SerializeIF {
   * @param bigEndian
   * @return
   */
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    Endianness streamEndianness) override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override;

  uint8_t* getBuffer();
-  const uint8_t* getConstBuffer() const;
-  void setBuffer(uint8_t* buffer, count_t bufferLength);
+  [[nodiscard]] const uint8_t* getConstBuffer() const;
+  void setConstBuffer(const uint8_t* buf, count_t bufLen);

 private:
  bool serializeLength = false;
--- a/src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp
@ -1,9 +1,8 @@
-#include "fsfw/serviceinterface/ServiceInterfaceBuffer.h"
+#include "ServiceInterfaceBuffer.h"

 #if FSFW_CPP_OSTREAM_ENABLED == 1

-#include <inttypes.h>
-
+#include <cinttypes>
 #include <cstring>

 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
@ -16,8 +15,6 @@
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);

-#ifndef UT699
-
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
                                               bool buffered, bool errStream, uint16_t port)
    : isActive(true),
@ -58,6 +55,9 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addC
 }

 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  if (not isActive) {
+    return;
+  }
  char array[BUF_SIZE];
  uint32_t length = end - begin;
  if (length > sizeof(array)) {
@ -74,8 +74,6 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
  }
 }

-#endif
-
 int ServiceInterfaceBuffer::overflow(int c) {
  if (not buffered and this->isActive) {
    if (c != Traits::eof()) {
@ -169,89 +167,4 @@ void ServiceInterfaceBuffer::setAsciiColorPrefix(std::string colorPrefix) {
 }
 #endif

-#ifdef UT699
-#include "../osal/rtems/Interrupt.h"
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
-  this->log_message = set_message;
-  this->isActive = true;
-  setp(buf, buf + BUF_SIZE);
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-  char array[BUF_SIZE];
-  uint32_t length = end - begin;
-  if (length > sizeof(array)) {
-    length = sizeof(array);
-  }
-  memcpy(array, begin, length);
-
-  if (!Interrupt::isInterruptInProgress()) {
-    std::cout << array;
-  } else {
-    // Uncomment the following line if you need ISR debug output.
-    //		printk(array);
-  }
-}
-#endif  // UT699
-
-#ifdef ML505
-#include <bsp_flp/network/networkconfig.h>
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port)
-    : isActive(true),
-      log_message(set_message),
-      udpSocket(0),
-      remoteAddressLength(sizeof(remoteAddress)) {
-  setp(buf, buf + BUF_SIZE);
-  memset((uint8_t*)&remoteAddress, 0, sizeof(remoteAddress));
-  remoteAddress.sin_family = AF_INET;
-  remoteAddress.sin_port = htons(port);
-  remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
-}
-
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-  char array[BUF_SIZE];
-  uint32_t length = end - begin;
-  if (length > sizeof(array)) {
-    length = sizeof(array);
-  }
-  memcpy(array, begin, length);
-
-  if (udpSocket <= 0) {
-    initSocket();
-  }
-
-  if (udpSocket > 0) {
-    sendto(udpSocket, array, length, 0, (sockaddr*)&remoteAddress, sizeof(remoteAddress));
-  }
-}
-
-void ServiceInterfaceBuffer::initSocket() {
-  sockaddr_in address;
-  memset((uint8_t*)&address, 0, sizeof(address));
-  address.sin_family = AF_INET;
-  address.sin_port = htons(0);
-  address.sin_addr.s_addr = htonl(INADDR_ANY);
-
-  udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
-  if (socket < 0) {
-    printf("Error opening socket!\n");
-    return;
-  }
-  timeval timeout = {0, 20};
-  if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
-    printf("Error setting SO_RCVTIMEO socket options!\n");
-    return;
-  }
-  if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
-    printf("Error setting SO_SNDTIMEO socket options!\n");
-    return;
-  }
-  if (bind(udpSocket, (sockaddr*)&address, sizeof(address)) < 0) {
-    printf("Error binding socket!\n");
-  }
-}
-
-#endif  // ML505
-
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif
--- a/src/fsfw/serviceinterface/ServiceInterfaceBuffer.h
+++ b/src/fsfw/serviceinterface/ServiceInterfaceBuffer.h
@ -1,9 +1,8 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_

-#include <FSFWConfig.h>
-
-#include "../returnvalues/returnvalue.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/returnvalues/returnvalue.h"

 #if FSFW_CPP_OSTREAM_ENABLED == 1

@ -11,8 +10,6 @@
 #include <iostream>
 #include <sstream>

-#ifndef UT699
-
 /**
 * @brief 	This is the underlying stream buffer which implements the
 * 			streambuf class and overloads the overflow() and sync() methods
@ -77,85 +74,6 @@ class ServiceInterfaceBuffer : public std::streambuf {
  bool crAdditionEnabled() const;
 };

-#endif
-
-#ifdef UT699
-class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
-  friend class ServiceInterfaceStream;
-
- public:
-  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-
- protected:
-  bool isActive;
-  // This is called when buffer becomes full. If
-  // buffer is not used, then this is called every
-  // time when characters are put to stream.
-  virtual int overflow(int c = Traits::eof());
-
-  // This function is called when stream is flushed,
-  // for example when std::endl is put to stream.
-  virtual int sync(void);
-
- private:
-  // For additional message information
-  std::string log_message;
-  // For EOF detection
-  typedef std::char_traits<char> Traits;
-
-  // Work in buffer mode. It is also possible to work without buffer.
-  static size_t const BUF_SIZE = 128;
-  char buf[BUF_SIZE];
-
-  // In this function, the characters are parsed.
-  void putChars(char const* begin, char const* end);
-};
-#endif  // UT699
-
-#ifdef ML505
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <netinet/udp.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-
-class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
-  friend class ServiceInterfaceStream;
-
- public:
-  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
-
- protected:
-  bool isActive;
-  // This is called when buffer becomes full. If
-  // buffer is not used, then this is called every
-  // time when characters are put to stream.
-  virtual int overflow(int c = Traits::eof());
-
-  // This function is called when stream is flushed,
-  // for example when std::endl is put to stream.
-  virtual int sync(void);
-
- private:
-  // For additional message information
-  std::string log_message;
-  // For EOF detection
-  typedef std::char_traits<char> Traits;
-
-  // Work in buffer mode. It is also possible to work without buffer.
-  static size_t const BUF_SIZE = 128;
-  char buf[BUF_SIZE];
-
-  // In this function, the characters are parsed.
-  void putChars(char const* begin, char const* end);
-
-  int udpSocket;
-  sockaddr_in remoteAddress;
-  socklen_t remoteAddressLength;
-  void initSocket();
-};
-#endif  // ML505
-
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */

 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */
--- a/src/fsfw/serviceinterface/ServiceInterfaceStream.h
+++ b/src/fsfw/serviceinterface/ServiceInterfaceStream.h
@ -1,9 +1,8 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_

-#include <FSFWConfig.h>
-
 #include "ServiceInterfaceBuffer.h"
+#include "fsfw/FSFW.h"

 #if FSFW_CPP_OSTREAM_ENABLED == 1

--- a/src/fsfw/subsystem/Subsystem.h
+++ b/src/fsfw/subsystem/Subsystem.h
@ -33,12 +33,8 @@ struct SequenceEntry : public TableSequenceBase {
 };

 /**
- * @brief   This class extends the SubsystemBase to perform the management of mode tables
- *          and mode sequences
+ * @brief   TODO: documentation missing
 * @details
- * This class is able to use mode tables and sequences to command all its children into the
- * right mode. Fallback sequences can be used to handle failed transitions or have a fallback
- * in case a component can't keep its current mode.
 */
 class Subsystem : public SubsystemBase, public HasModeSequenceIF {
 public:
--- a/src/fsfw/subsystem/SubsystemBase.cpp
+++ b/src/fsfw/subsystem/SubsystemBase.cpp
@ -8,13 +8,11 @@ SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent, Mode_t
                             uint16_t commandQueueDepth)
    : SystemObject(setObjectId),
      mode(initialMode),
+      commandQueue(QueueFactory::instance()->createMessageQueue(commandQueueDepth,
+                                                                CommandMessage::MAX_MESSAGE_SIZE)),
      healthHelper(this, setObjectId),
      modeHelper(this),
-      parentId(parent) {
-  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      commandQueueDepth, CommandMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
+      parentId(parent) {}

 SubsystemBase::~SubsystemBase() { QueueFactory::instance()->deleteMessageQueue(commandQueue); }

@ -33,9 +31,8 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
      info.mode = MODE_OFF;
    }
  } else {
-    // intentional to force an initial command during system startup
    info.commandQueue = child->getCommandQueue();
-    info.mode = HasModesIF::MODE_UNDEFINED;
+    info.mode = -1;  // intentional to force an initial command during system startup
  }

  info.submode = SUBMODE_NONE;
--- a/src/fsfw/subsystem/SubsystemBase.h
+++ b/src/fsfw/subsystem/SubsystemBase.h
@ -15,14 +15,7 @@

 /**
 * @defgroup subsystems Subsystem Objects
- * All Subsystem and Assemblies can derive from this class. It contains helper classes to
- * perform mode and health handling, which allows OBSW developers to build a mode tree for
- * the whole satellite.
- *
- * Aside from setting up a mode tree and being able to executing mode tables, this class does not
- * provide an implementation on what to do with the features. To build a mode tree, helper classes
- * like the #AssemblyBase or the #Subsystem class extend and use the functionality of the base
- * class.
+ * Contains all Subsystem and Assemblies
 */
 class SubsystemBase : public SystemObject,
                      public HasModesIF,
@ -102,7 +95,6 @@ class SubsystemBase : public SystemObject,
                                       Submode_t targetSubmode);

  /**
-   * This function takes care of sending all according mode commands specified inside a mode table.
   * 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
   */
--- a/src/fsfw/tcdistribution/CCSDSDistributor.cpp
+++ b/src/fsfw/tcdistribution/CCSDSDistributor.cpp
@ -59,7 +59,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
  }
 }

-MessageQueueId_t CCSDSDistributor::getRequestQueue() { return tcQueue->getId(); }
+MessageQueueId_t CCSDSDistributor::getRequestQueue() const { return tcQueue->getId(); }

 ReturnValue_t CCSDSDistributor::registerApplication(AcceptsTelecommandsIF* application) {
  ReturnValue_t returnValue = returnvalue::OK;
@ -80,7 +80,7 @@ ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid, MessageQueueI
  return returnValue;
 }

-uint16_t CCSDSDistributor::getIdentifier() { return 0; }
+uint32_t CCSDSDistributor::getIdentifier() const { return 0; }

 ReturnValue_t CCSDSDistributor::initialize() {
  if (packetChecker == nullptr) {
--- a/src/fsfw/tcdistribution/CCSDSDistributor.h
+++ b/src/fsfw/tcdistribution/CCSDSDistributor.h
@ -35,10 +35,10 @@ class CCSDSDistributor : public TcDistributor,
   */
  ~CCSDSDistributor() override;

-  MessageQueueId_t getRequestQueue() override;
+  MessageQueueId_t getRequestQueue() const override;
  ReturnValue_t registerApplication(uint16_t apid, MessageQueueId_t id) override;
  ReturnValue_t registerApplication(AcceptsTelecommandsIF* application) override;
-  uint16_t getIdentifier() override;
+  uint32_t getIdentifier() const override;
  ReturnValue_t initialize() override;

 protected:
--- a/src/fsfw/tcdistribution/CFDPDistributor.h
+++ b/src/fsfw/tcdistribution/CFDPDistributor.h
@ -33,9 +33,9 @@ class CFDPDistributor : public TcDistributor,
   */
  ~CFDPDistributor() override;
  ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) override;
-  MessageQueueId_t getRequestQueue() override;
+  MessageQueueId_t getRequestQueue() const override;
  ReturnValue_t initialize() override;
-  uint16_t getIdentifier() override;
+  uint32_t getIdentifier() const override;

 protected:
  uint16_t apid;
--- a/src/fsfw/tcdistribution/CMakeLists.txt
+++ b/src/fsfw/tcdistribution/CMakeLists.txt
@ -1,9 +1,4 @@
 target_sources(
  ${LIB_FSFW_NAME}
-  PRIVATE CCSDSDistributor.cpp
-          PusDistributor.cpp
-          TcDistributor.cpp
-          PusPacketChecker.cpp
-          TcPacketCheckCFDP.cpp
-          CFDPDistributor.cpp
-          CcsdsPacketChecker.cpp)
+  PRIVATE CCSDSDistributor.cpp PusDistributor.cpp TcDistributor.cpp
+          TcPacketCheckCFDP.cpp CcsdsPacketChecker.cpp)
--- a/src/fsfw/tcdistribution/PusDistributor.cpp
+++ b/src/fsfw/tcdistribution/PusDistributor.cpp
@ -97,7 +97,7 @@ ReturnValue_t PusDistributor::registerService(AcceptsTelecommandsIF* service) {
  return returnvalue::OK;
 }

-MessageQueueId_t PusDistributor::getRequestQueue() { return tcQueue->getId(); }
+MessageQueueId_t PusDistributor::getRequestQueue() const { return tcQueue->getId(); }

 ReturnValue_t PusDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
  if (queueStatus != returnvalue::OK) {
@ -115,7 +115,7 @@ ReturnValue_t PusDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
  }
 }

-uint16_t PusDistributor::getIdentifier() { return checker.getApid(); }
+uint32_t PusDistributor::getIdentifier() const { return checker.getApid(); }

 ReturnValue_t PusDistributor::initialize() {
  if (store == nullptr) {
@ -146,7 +146,7 @@ ReturnValue_t PusDistributor::initialize() {

 void PusDistributor::checkerFailurePrinter() const {
 #if FSFW_VERBOSE_LEVEL >= 1
-  const char* keyword = "unnamed";
+  const char* keyword = "unnamed error";
  if (tcStatus == tcdistrib::INCORRECT_CHECKSUM) {
    keyword = "checksum";
  } else if (tcStatus == tcdistrib::INCORRECT_PRIMARY_HEADER) {
@ -157,8 +157,6 @@ void PusDistributor::checkerFailurePrinter() const {
    keyword = "incorrect secondary header";
  } else if (tcStatus == tcdistrib::INCOMPLETE_PACKET) {
    keyword = "incomplete packet";
-  } else if (tcStatus == tcdistrib::INVALID_SEC_HEADER_FIELD) {
-    keyword = "invalid secondary header field";
  }
 #if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword << " error"
--- a/src/fsfw/tcdistribution/PusDistributor.h
+++ b/src/fsfw/tcdistribution/PusDistributor.h
@ -34,9 +34,9 @@ class PusDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   */
  ~PusDistributor() override;
  ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
-  MessageQueueId_t getRequestQueue() override;
+  MessageQueueId_t getRequestQueue() const override;
  ReturnValue_t initialize() override;
-  uint16_t getIdentifier() override;
+  uint32_t getIdentifier() const override;

 protected:
  StorageManagerIF* store;
--- a/src/fsfw/tcdistribution/TcDistributor.cpp
+++ b/src/fsfw/tcdistribution/TcDistributor.cpp
@ -5,9 +5,7 @@
 #include "fsfw/tmtcservices/TmTcMessage.h"

 TcDistributor::TcDistributor(object_id_t objectId) : SystemObject(objectId) {
-  auto mqArgs = MqArgs(objectId);
-  tcQueue = QueueFactory::instance()->createMessageQueue(
-      DISTRIBUTER_MAX_PACKETS, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  tcQueue = QueueFactory::instance()->createMessageQueue(DISTRIBUTER_MAX_PACKETS);
 }

 TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); }
--- a/src/fsfw/tcdistribution/definitions.h
+++ b/src/fsfw/tcdistribution/definitions.h
@ -14,11 +14,11 @@ static constexpr ReturnValue_t INVALID_PACKET_TYPE = MAKE_RETURN_CODE(2);
 static constexpr ReturnValue_t INVALID_SEC_HEADER_FIELD = MAKE_RETURN_CODE(3);
 static constexpr ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(4);

-static constexpr ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(5);
-static constexpr ReturnValue_t INVALID_PUS_VERSION = MAKE_RETURN_CODE(6);
-static constexpr ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(7);
-static constexpr ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(8);
-static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(9);
+static constexpr ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(7);
+static constexpr ReturnValue_t INVALID_PUS_VERSION = MAKE_RETURN_CODE(8);
+static constexpr ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(9);
+static constexpr ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(10);
+static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(11);

 };      // namespace tcdistrib
 #endif  // FSFW_TMTCPACKET_DEFINITIONS_H
--- a/src/fsfw/thermal/AbstractTemperatureSensor.cpp
+++ b/src/fsfw/thermal/AbstractTemperatureSensor.cpp
@ -4,13 +4,14 @@

 AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
                                                     ThermalModuleIF *thermalModule)
-    : SystemObject(setObjectid), healthHelper(this, setObjectid), parameterHelper(this) {
-  if (thermalModule != nullptr) {
+    : SystemObject(setObjectid),
+      commandQueue(NULL),
+      healthHelper(this, setObjectid),
+      parameterHelper(this) {
+  if (thermalModule != NULL) {
    thermalModule->registerSensor(this);
  }
-  auto mqArgs = MqArgs(setObjectid, static_cast<void *>(this));
-  commandQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  commandQueue = QueueFactory::instance()->createMessageQueue();
 }

 AbstractTemperatureSensor::~AbstractTemperatureSensor() {
--- a/src/fsfw/thermal/AbstractTemperatureSensor.h
+++ b/src/fsfw/thermal/AbstractTemperatureSensor.h
@ -51,7 +51,7 @@ class AbstractTemperatureSensor : public HasHealthIF,
  HasHealthIF::HealthState getHealth();

 protected:
-  MessageQueueIF* commandQueue = nullptr;
+  MessageQueueIF* commandQueue;
  HealthHelper healthHelper;
  ParameterHelper parameterHelper;

--- a/src/fsfw/thermal/Heater.cpp
+++ b/src/fsfw/thermal/Heater.cpp
@ -12,9 +12,7 @@ Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1)
      switch1(switch1),
      heaterOnCountdown(10800000) /*about two orbits*/,
      parameterHelper(this) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  eventQueue = QueueFactory::instance()->createMessageQueue(
-      3, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  eventQueue = QueueFactory::instance()->createMessageQueue();
 }

 Heater::~Heater() { QueueFactory::instance()->deleteMessageQueue(eventQueue); }
--- a/src/fsfw/thermal/ThermalComponentIF.h
+++ b/src/fsfw/thermal/ThermalComponentIF.h
@ -13,9 +13,9 @@ class ThermalComponentIF : public HasParametersIF {
  static const Event COMPONENT_TEMP_HIGH = MAKE_EVENT(2, severity::LOW);
  static const Event COMPONENT_TEMP_OOL_LOW = MAKE_EVENT(3, severity::LOW);
  static const Event COMPONENT_TEMP_OOL_HIGH = MAKE_EVENT(4, severity::LOW);
-  //!< Is thrown when a device should start-up, but the temperature is out
-  //!< of OP range. P1: thermalState of the component, P2: 0
-  static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(5, severity::LOW);
+  static const Event TEMP_NOT_IN_OP_RANGE = MAKE_EVENT(
+      5, severity::LOW);  //!< Is thrown when a device should start-up, but the temperature is out
+                          //!< of OP range. P1: thermalState of the component, P2: 0

  static const uint8_t INTERFACE_ID = CLASS_ID::THERMAL_COMPONENT_IF;
  static const ReturnValue_t INVALID_TARGET_STATE = MAKE_RETURN_CODE(1);
--- a/src/fsfw/timemanager/CdsShortTimeStamper.cpp
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.cpp
@ -6,11 +6,6 @@

 CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}

-ReturnValue_t CdsShortTimeStamper::addTimeStamp(uint8_t *buffer, const uint8_t maxSize) {
-  size_t serLen = 0;
-  return serialize(&buffer, &serLen, maxSize, SerializeIF::Endianness::NETWORK);
-}
-
 ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                             SerializeIF::Endianness streamEndianness) const {
  if (*size + getSerializedSize() > maxSize) {
@ -33,15 +28,22 @@ size_t CdsShortTimeStamper::getSerializedSize() const { return getTimestampSize(

 ReturnValue_t CdsShortTimeStamper::deSerialize(const uint8_t **buffer, size_t *size,
                                               SerializeIF::Endianness streamEndianness) {
-  return returnvalue::FAILED;
-}
-
-ReturnValue_t CdsShortTimeStamper::readTimeStamp(const uint8_t *buffer, size_t maxSize) {
-  if (maxSize < getTimestampSize()) {
+  if (size == nullptr or buffer == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (*size < getTimestampSize()) {
    return SerializeIF::STREAM_TOO_SHORT;
  }
  size_t foundLen = 0;
-  return CCSDSTime::convertFromCcsds(&readTime, buffer, &foundLen, maxSize);
+  if (((**buffer >> 4) & 0b111) != CCSDSTime::TimeCodeIdentification::CDS) {
+    return BAD_TIMESTAMP;
+  }
+  auto res = CCSDSTime::convertFromCcsds(&readTime, *buffer, &foundLen, *size);
+  if (res == returnvalue::OK) {
+    *size -= getSerializedSize();
+    *buffer += getSerializedSize();
+  }
+  return res;
 }

 timeval &CdsShortTimeStamper::getTime() { return readTime; }
--- a/src/fsfw/timemanager/CdsShortTimeStamper.h
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.h
@ -3,7 +3,7 @@

 #include "CCSDSTime.h"
 #include "TimeReaderIF.h"
-#include "TimeStamperIF.h"
+#include "TimeWriterIF.h"
 #include "fsfw/objectmanager/SystemObject.h"

 /**
@ -15,7 +15,7 @@
 * overriding the #addTimeStamp function.
 * @ingroup utility
 */
-class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public SystemObject {
+class CdsShortTimeStamper : public TimeWriterIF, public TimeReaderIF, public SystemObject {
 public:
  static constexpr size_t TIMESTAMP_LEN = 7;
  /**
@ -25,20 +25,11 @@ class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public Sy
   */
  explicit CdsShortTimeStamper(object_id_t objectId);

-  /**
-   * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
-   * This function can be overriden to use a custom timestamp.
-   * @param buffer
-   * @param maxSize
-   * @return
-   */
-  ReturnValue_t addTimeStamp(uint8_t *buffer, uint8_t maxSize) override;
  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                          Endianness streamEndianness) const override;
  [[nodiscard]] size_t getSerializedSize() const override;
  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                            Endianness streamEndianness) override;
-  ReturnValue_t readTimeStamp(const uint8_t *buffer, size_t maxSize) override;
  timeval &getTime() override;
  [[nodiscard]] size_t getTimestampSize() const override;

--- a/src/fsfw/timemanager/Countdown.cpp
+++ b/src/fsfw/timemanager/Countdown.cpp
@ -1,11 +1,7 @@
 #include "fsfw/timemanager/Countdown.h"

-Countdown::Countdown(uint32_t initialTimeout, bool startImmediately) : timeout(initialTimeout) {
-  if (startImmediately) {
-    setTimeout(initialTimeout);
-  } else {
-    timeout = initialTimeout;
-  }
+Countdown::Countdown(uint32_t initialTimeout) : timeout(initialTimeout) {
+  setTimeout(initialTimeout);
 }

 Countdown::~Countdown() {}
--- a/src/fsfw/timemanager/Countdown.h
+++ b/src/fsfw/timemanager/Countdown.h
@ -26,9 +26,8 @@ class Countdown {
   * Otherwise a call to hasTimedOut might return True.
   *
   * @param initialTimeout Countdown duration in milliseconds
-   * @param startImmediately  Set to false if countdown should not be started immediately
   */
-  Countdown(uint32_t initialTimeout = 0, bool startImmediately = true);
+  Countdown(uint32_t initialTimeout = 0);
  ~Countdown();
  /**
   * Call to set a new countdown duration.
--- a/src/fsfw/timemanager/TimeReaderIF.h
+++ b/src/fsfw/timemanager/TimeReaderIF.h
@ -5,12 +5,28 @@

 #include "TimeStampIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/serialize/SerializeIF.h"

-class TimeReaderIF : public TimeStampIF {
+class TimeReaderIF : public SerializeIF, public TimeStampIF {
 public:
  ~TimeReaderIF() override = default;
-  virtual ReturnValue_t readTimeStamp(const uint8_t* buffer, size_t maxSize) = 0;
  virtual timeval& getTime() = 0;
+
+  [[nodiscard]] size_t getSerializedSize() const override { return getTimestampSize(); }
+
+  ReturnValue_t readTimeStamp(const uint8_t* buf, size_t maxSize) {
+    size_t dummy = 0;
+    return deSerialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+ private:
+  /**
+   *   Forbidden, use dedicated IF @TimeWriterIF
+   */
+  [[nodiscard]] ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                        Endianness streamEndianness) const override {
+    return returnvalue::FAILED;
+  }
 };

 #endif  // FSFW_TIMEMANAGER_TIMEREADERIF_H
--- a/src/fsfw/timemanager/TimeStamperIF.h
+++ b/src/fsfw/timemanager/TimeStamperIF.h
@ -1,23 +0,0 @@
-#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
-#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
-
-#include "TimeStampIF.h"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "fsfw/serialize/SerializeIF.h"
-
-/**
- * A class implementing this IF provides facilities to add a time stamp to the
- * buffer provided.
- * Implementors need to ensure that calling the method is thread-safe, i.e.
- * addTimeStamp may be called in parallel from a different context.
- */
-class TimeStamperIF : public SerializeIF, public TimeStampIF {
- public:
-  virtual ReturnValue_t addTimeStamp(uint8_t* buffer, uint8_t maxSize) = 0;
-  ~TimeStamperIF() override = default;
-  size_t getTimestampSize() const override { return getSerializedSize(); }
-
- protected:
-};
-
-#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */
--- a/src/fsfw/timemanager/TimeWriterIF.h
+++ b/src/fsfw/timemanager/TimeWriterIF.h
@ -0,0 +1,34 @@
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPERIF_H_
+
+#include "TimeStampIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/serialize/SerializeIF.h"
+
+/**
+ * A class implementing this IF provides facilities to add a time stamp to the
+ * buffer provided.
+ * Implementors need to ensure that calling the method is thread-safe, i.e.
+ * addTimeStamp may be called in parallel from a different context.
+ */
+class TimeWriterIF : public SerializeIF, public TimeStampIF {
+ public:
+  ~TimeWriterIF() override = default;
+  [[nodiscard]] size_t getTimestampSize() const override { return getSerializedSize(); }
+
+  ReturnValue_t addTimeStamp(uint8_t *buf, size_t maxSize) {
+    size_t dummy = 0;
+    return serialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
+ private:
+  /**
+   *   Forbidden, use dedicated IF @TimeReaderIF
+   */
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
+    return returnvalue::FAILED;
+  }
+};
+
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPERIF_H_ */
--- a/src/fsfw/tmstorage/TmStoreBackendIF.h
+++ b/src/fsfw/tmstorage/TmStoreBackendIF.h
@ -33,47 +33,50 @@ class TmStoreBackendIF : public HasParametersIF {
  static const ReturnValue_t INVALID_REQUEST = MAKE_RETURN_CODE(15);

  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MEMORY;
-  //! Initiating sending data to store failed. Low, par1:
-  //! returnCode, par2: integer (debug info)
-  static const Event STORE_SEND_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
-  //! Data was sent, but writing failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_WRITE_FAILED = MAKE_EVENT(1, severity::LOW);
-  //! Initiating reading data from store failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_SEND_READ_FAILED = MAKE_EVENT(2, severity::LOW);
-  //! Data was requested, but access failed. Low, par1: returnCode, par2: 0
-  static const Event STORE_READ_FAILED = MAKE_EVENT(3, severity::LOW);
-  //! An unexpected TM packet or data message occurred. Low, par1: 0, par2: integer (debug info)
-  static const Event UNEXPECTED_MSG = MAKE_EVENT(4, severity::LOW);
-  //! Storing data failed. May simply be a full store. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event STORING_FAILED = MAKE_EVENT(5, severity::LOW);
-  //! Dumping retrieved data failed. Low, par1: returnCode,
-  //! par2: integer (sequence count of failed packet).
-  static const Event TM_DUMP_FAILED = MAKE_EVENT(6, severity::LOW);
-  //! Corrupted init data or read error. Low, par1: returnCode, par2: integer (debug info)
-  //! Store was not initialized. Starts empty. Info, parameters both zero.
-  static const Event STORE_INIT_FAILED = MAKE_EVENT(7, severity::LOW);
-  //! Data was read out, but it is inconsistent. Low par1:
-  //! Memory address of corruption, par2: integer (debug info)
-  static const Event STORE_INIT_EMPTY = MAKE_EVENT(8, severity::INFO);
-
-  static const Event STORE_CONTENT_CORRUPTED = MAKE_EVENT(9, severity::LOW);
-  //! Info event indicating the store will be initialized, either at boot or after IOB switch.
-  //! Info. pars: 0
-  static const Event STORE_INITIALIZE = MAKE_EVENT(10, severity::INFO);
-  //! Info event indicating the store was successfully initialized, either at boot or after
-  //! IOB switch. Info. pars: 0
-  static const Event INIT_DONE = MAKE_EVENT(11, severity::INFO);
-  //! Info event indicating that dumping finished successfully.
-  //! par1: Number of dumped packets. par2: APID/SSC (16bits each)
-  static const Event DUMP_FINISHED = MAKE_EVENT(12, severity::INFO);
-  //! Info event indicating that deletion finished successfully.
-  //! par1:Number of deleted packets. par2: APID/SSC (16bits each)
-  static const Event DELETION_FINISHED = MAKE_EVENT(13, severity::INFO);
-  //! Info event indicating that something went wrong during deletion. pars: 0
-  static const Event DELETION_FAILED = MAKE_EVENT(14, severity::LOW);
-  //! Info that the a auto catalog report failed
-  static const Event AUTO_CATALOGS_SENDING_FAILED = MAKE_EVENT(15, severity::INFO);
+  static const Event STORE_SEND_WRITE_FAILED =
+      MAKE_EVENT(0, severity::LOW);  //!< Initiating sending data to store failed. Low, par1:
+                                     //!< returnCode, par2: integer (debug info)
+  static const Event STORE_WRITE_FAILED = MAKE_EVENT(
+      1, severity::LOW);  //!< Data was sent, but writing failed. Low, par1: returnCode, par2: 0
+  static const Event STORE_SEND_READ_FAILED =
+      MAKE_EVENT(2, severity::LOW);  //!< Initiating reading data from store failed. Low, par1:
+                                     //!< returnCode, par2: 0
+  static const Event STORE_READ_FAILED = MAKE_EVENT(
+      3, severity::LOW);  //!< Data was requested, but access failed. Low, par1: returnCode, par2: 0
+  static const Event UNEXPECTED_MSG =
+      MAKE_EVENT(4, severity::LOW);  //!< An unexpected TM packet or data message occurred. Low,
+                                     //!< par1: 0, par2: integer (debug info)
+  static const Event STORING_FAILED = MAKE_EVENT(
+      5, severity::LOW);  //!< Storing data failed. May simply be a full store. Low, par1:
+                          //!< returnCode, par2: integer (sequence count of failed packet).
+  static const Event TM_DUMP_FAILED =
+      MAKE_EVENT(6, severity::LOW);  //!< Dumping retrieved data failed. Low, par1: returnCode,
+                                     //!< par2: integer (sequence count of failed packet).
+  static const Event STORE_INIT_FAILED =
+      MAKE_EVENT(7, severity::LOW);  //!< Corrupted init data or read error. Low, par1: returnCode,
+                                     //!< par2: integer (debug info)
+  static const Event STORE_INIT_EMPTY = MAKE_EVENT(
+      8, severity::INFO);  //!< Store was not initialized. Starts empty. Info, parameters both zero.
+  static const Event STORE_CONTENT_CORRUPTED =
+      MAKE_EVENT(9, severity::LOW);  //!< Data was read out, but it is inconsistent. Low par1:
+                                     //!< Memory address of corruption, par2: integer (debug info)
+  static const Event STORE_INITIALIZE =
+      MAKE_EVENT(10, severity::INFO);  //!< Info event indicating the store will be initialized,
+                                       //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event INIT_DONE = MAKE_EVENT(
+      11, severity::INFO);  //!< Info event indicating the store was successfully initialized,
+                            //!< either at boot or after IOB switch. Info. pars: 0
+  static const Event DUMP_FINISHED = MAKE_EVENT(
+      12, severity::INFO);  //!< Info event indicating that dumping finished successfully. par1:
+                            //!< Number of dumped packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FINISHED = MAKE_EVENT(
+      13, severity::INFO);  //!< Info event indicating that deletion finished successfully. par1:
+                            //!< Number of deleted packets. par2: APID/SSC (16bits each)
+  static const Event DELETION_FAILED = MAKE_EVENT(
+      14,
+      severity::LOW);  //!< Info event indicating that something went wrong during deletion. pars: 0
+  static const Event AUTO_CATALOGS_SENDING_FAILED =
+      MAKE_EVENT(15, severity::INFO);  //!< Info that the a auto catalog report failed

  virtual ~TmStoreBackendIF() {}

--- a/src/fsfw/tmstorage/TmStorePackets.h
+++ b/src/fsfw/tmstorage/TmStorePackets.h
@ -7,7 +7,7 @@
 #include "fsfw/serialize/SerialLinkedListAdapter.h"
 #include "fsfw/serialize/SerializeElement.h"
 #include "fsfw/timemanager/CCSDSTime.h"
-#include "fsfw/timemanager/TimeStamperIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
 #include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
 #include "tmStorageConf.h"

--- a/src/fsfw/tmtcpacket/ccsds/defs.h
+++ b/src/fsfw/tmtcpacket/ccsds/defs.h
@ -23,11 +23,11 @@ constexpr uint16_t getSpacePacketIdFromApid(bool isTc, uint16_t apid,
  return ((isTc << 4) | (secondaryHeaderFlag << 3) | ((apid >> 8) & 0x07)) << 8 | (apid & 0x00ff);
 }

-constexpr uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag = true) {
+constexpr uint16_t getTcSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag) {
  return getSpacePacketIdFromApid(true, apid, secondaryHeaderFlag);
 }

-constexpr uint16_t getTmSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag = true) {
+constexpr uint16_t getTmSpacePacketIdFromApid(uint16_t apid, bool secondaryHeaderFlag) {
  return getSpacePacketIdFromApid(false, apid, secondaryHeaderFlag);
 }

--- a/src/fsfw/tmtcpacket/pus/CustomUserDataIF.h
+++ b/src/fsfw/tmtcpacket/pus/CustomUserDataIF.h
@ -7,6 +7,6 @@ class CustomUserDataIF {
 public:
  virtual ~CustomUserDataIF() = default;
  virtual ReturnValue_t setRawUserData(const uint8_t* data, size_t len) = 0;
-  virtual ReturnValue_t setSerializableUserData(SerializeIF& serializable) = 0;
+  virtual ReturnValue_t setSerializableUserData(const SerializeIF& serializable) = 0;
 };
 #endif  // FSFW_TMTCPACKET_CREATORDATAIF_H
--- a/src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp
+++ b/src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp
@ -14,7 +14,6 @@ PusTcCreator::PusTcCreator(SpacePacketParams spParams, PusTcParams pusParams)
 ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                      SerializeIF::Endianness streamEndianness) const {
  const uint8_t *start = *buffer;
-  size_t userDataLen = pusParams.dataWrapper.getLength();
  if (*size + getSerializedSize() > maxSize) {
    return SerializeIF::BUFFER_TOO_SHORT;
  }
@ -37,17 +36,8 @@ ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t max
  if (result != returnvalue::OK) {
    return result;
  }
-  if (pusParams.dataWrapper.type == util::DataTypes::RAW) {
-    const uint8_t *data = pusParams.dataWrapper.dataUnion.raw.data;
-    if (data != nullptr and userDataLen > 0) {
-      std::memcpy(*buffer, data, userDataLen);
-      *buffer += userDataLen;
-      *size += userDataLen;
-    }
-  } else if (pusParams.dataWrapper.type == util::DataTypes::SERIALIZABLE and
-             pusParams.dataWrapper.dataUnion.serializable != nullptr) {
-    result = pusParams.dataWrapper.dataUnion.serializable->serialize(buffer, size, maxSize,
-                                                                     streamEndianness);
+  if (pusParams.appData != nullptr) {
+    result = pusParams.appData->serialize(buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
@ -58,8 +48,11 @@ ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t max
 }

 void PusTcCreator::updateSpLengthField() {
-  spCreator.setDataLen(ecss::PusTcDataFieldHeader::MIN_SIZE + pusParams.dataWrapper.getLength() +
-                       1);
+  size_t len = ecss::PusTcDataFieldHeader::MIN_SIZE + 1;
+  if (pusParams.appData != nullptr) {
+    len += pusParams.appData->getSerializedSize();
+  }
+  spCreator.setDataLen(len);
 }

 size_t PusTcCreator::getSerializedSize() const { return spCreator.getFullPacketLen(); }
@ -91,14 +84,15 @@ SpacePacketParams &PusTcCreator::getSpParams() { return spCreator.getParams(); }

 ReturnValue_t PusTcCreator::setRawUserData(const uint8_t *data, size_t len) {
  // TODO: Check length field?
-  pusParams.dataWrapper.setRawData({data, len});
+  pusParams.bufAdapter.setConstBuffer(data, len);
+  pusParams.appData = &pusParams.bufAdapter;
  updateSpLengthField();
  return returnvalue::OK;
 }

-ReturnValue_t PusTcCreator::setSerializableUserData(SerializeIF &serializable) {
+ReturnValue_t PusTcCreator::setSerializableUserData(const SerializeIF &serializable) {
  // TODO: Check length field?
-  pusParams.dataWrapper.setSerializable(serializable);
+  pusParams.appData = &serializable;
  updateSpLengthField();
  return returnvalue::OK;
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robin Mueller	f805667779	afmt	2022-10-28 10:16:59 +02:00
Ulrich Mohr	bddc7a7ca6	minimal first version	2022-10-26 13:22:16 +02:00
Ulrich Mohr	11a22577be	defaultconfig did not build anymore	2022-10-25 11:28:13 +02:00
Steffen Gaisser	94f1f1f908	Merge pull request 'Refactor TM and TC acceptor interfaces' (#684 ) from mueller/refactor-accepts-tc-tm-if into development Reviewed-on: fsfw/fsfw#684	2022-10-24 17:10:03 +02:00
Steffen Gaisser	955579c856	Merge branch 'development' into mueller/refactor-accepts-tc-tm-if	2022-10-24 14:57:38 +02:00
Steffen Gaisser	c6585c8645	Merge pull request 'important bugfix for linux i2c device com IF' (#700 ) from eive/fsfw:mueller/i2c-com-if-bugfix into development Reviewed-on: fsfw/fsfw#700	2022-10-24 14:35:01 +02:00
Robin Mueller	d8a4675842	bump changelog	2022-10-24 14:30:14 +02:00
Robin Mueller	1164c21ddd	iter not a member anymore, more bugfixes	2022-10-24 14:23:43 +02:00
Robin Mueller	77b1a85b47	important bugfix for i2c device com IF	2022-10-20 14:24:40 +02:00
Steffen Gaisser	f3e9277e59	Merge branch 'development' into mueller/refactor-accepts-tc-tm-if	2022-10-10 15:45:05 +02:00
Steffen Gaisser	d592f1ecbc	Merge pull request 'Minor API tweak' (#689 ) from eive/fsfw:mueller/smaller-tweaks into development Reviewed-on: fsfw/fsfw#689	2022-10-10 15:10:57 +02:00
Ulrich Mohr	6ec18171a8	Merge pull request 'now that doc server is up, remove markdown files' (#688 ) from mueller/remove-markdown-docs into development Reviewed-on: fsfw/fsfw#688	2022-10-10 15:04:11 +02:00
Steffen Gaisser	518dcdef4b	Merge branch 'development' into mueller/smaller-tweaks	2022-10-10 15:03:04 +02:00
Ulrich Mohr	d9730032fd	Merge pull request 'DHB Countdown Bug' (#693 ) from eive/fsfw:mueller/dhb-countdown-bug into development Reviewed-on: fsfw/fsfw#693	2022-10-10 14:55:43 +02:00
Steffen Gaisser	b3ac72b7db	Merge pull request 'missing retval conv' (#697 ) from mueller/missing-retval-conversion into development Reviewed-on: fsfw/fsfw#697	2022-10-10 14:54:26 +02:00
Steffen Gaisser	cd0cb43412	Merge branch 'development' into mueller/missing-retval-conversion	2022-10-10 14:46:10 +02:00
Steffen Gaisser	32c12b3dbf	Merge pull request 'small fix for helper' (#698 ) from mueller/small-helper-script-fix into development Reviewed-on: fsfw/fsfw#698	2022-10-10 14:43:59 +02:00
Steffen Gaisser	3e9acf476e	Merge branch 'development' into mueller/small-helper-script-fix	2022-10-10 14:25:49 +02:00
Steffen Gaisser	99101ce2bf	Merge pull request 'hotfix' (#699 ) from eive/fsfw:mueller/dhb-some-more-fixes into development Reviewed-on: fsfw/fsfw#699	2022-10-10 14:22:30 +02:00
Robin Müller	6b991045f7	Merge branch 'development' into mueller/smaller-tweaks	2022-10-10 13:41:47 +02:00
Robin Mueller	337cb0d6c9	hotfix	2022-10-10 10:21:17 +02:00
Robin Mueller	c283e0c988	okay this is correct	2022-10-04 11:02:08 +02:00
Robin Mueller	448d20f3bd	small fix for helper	2022-10-04 10:55:46 +02:00
Robin Müller	2316728d74	Merge branch 'development' into mueller/dhb-countdown-bug	2022-10-04 10:53:26 +02:00
Robin Mueller	6f562e5f3e	missing retval conv	2022-10-04 10:25:58 +02:00
Ulrich Mohr	176f243194	Merge pull request 'Switch to new documentation server' (#694 ) from mohr/documentation_ci into development Reviewed-on: fsfw/fsfw#694	2022-09-30 15:05:16 +02:00
Ulrich Mohr	d964fa2107	Merge branch 'development' into mohr/documentation_ci	2022-09-30 14:50:20 +02:00
Ulrich Mohr	7b5ae6a445	done?	2022-09-30 14:40:59 +02:00
Ulrich Mohr	8e362a000c	Revert "one last check" This reverts commit `7877776e24`.	2022-09-30 14:36:25 +02:00
Ulrich Mohr	7877776e24	one last check	2022-09-30 14:34:25 +02:00
Robin Mueller	3de0ae5a48	DHB bug	2022-09-29 17:22:44 +02:00
Steffen Gaisser	95ac53c417	Merge branch 'development' into mueller/smaller-tweaks	2022-09-26 14:40:29 +02:00
Steffen Gaisser	62f638a3d2	Merge pull request 'doc corrections' (#687 ) from mueller/doc-corrections into development Reviewed-on: fsfw/fsfw#687	2022-09-26 14:38:39 +02:00
Steffen Gaisser	bd64591f30	Merge branch 'development' into mueller/smaller-tweaks	2022-09-26 14:34:38 +02:00
Steffen Gaisser	e6a877f048	Merge branch 'development' into mueller/doc-corrections	2022-09-26 14:26:48 +02:00
Steffen Gaisser	ea8c557ee8	Merge pull request 'better error printout' (#686 ) from eive/fsfw:mueller/local-pool-obj-base-better-warning into development Reviewed-on: fsfw/fsfw#686	2022-09-26 14:26:20 +02:00
Steffen Gaisser	0bdd780f82	Merge branch 'development' into mueller/doc-corrections	2022-09-26 14:17:24 +02:00
Steffen Gaisser	9ec397c8b7	Merge branch 'development' into mueller/local-pool-obj-base-better-warning	2022-09-26 14:17:19 +02:00
Robin Mueller	c54d9d7ba6	add some tests	2022-09-26 14:15:11 +02:00
Steffen Gaisser	30c03c110c	Merge pull request 'include correction' (#683 ) from mueller/service-interface-include-correction into development Reviewed-on: fsfw/fsfw#683	2022-09-26 14:14:57 +02:00
Steffen Gaisser	69f1be263a	Merge branch 'development' into mueller/local-pool-obj-base-better-warning	2022-09-26 14:10:21 +02:00
Robin Müller	c7b5309dcb	Merge branch 'development' into mueller/service-interface-include-correction	2022-09-26 14:08:38 +02:00
Ulrich Mohr	775d5632de	update to ssh connection to doc server	2022-09-23 20:26:45 +02:00
Ulrich Mohr	4f3361eb2b	another ci check	2022-09-23 18:33:47 +02:00
Ulrich Mohr	9e6c1d60e5	another ci check	2022-09-23 17:54:41 +02:00
Ulrich Mohr	12d0c23c13	Revert "testing deployment of documentation" This reverts commit `5488ee715f`.	2022-09-23 17:31:17 +02:00
Ulrich Mohr	5c3bb13834	Revert "testing deployment of both development and master doc" This reverts commit `c0000a8635`.	2022-09-23 17:31:07 +02:00
Ulrich Mohr	292fe3e5e4	forgot epilog file	2022-09-23 17:11:57 +02:00
Ulrich Mohr	33530f2819	adding Impressum and Datenschutz to lcov output	2022-09-23 17:04:35 +02:00
Ulrich Mohr	c0000a8635	testing deployment of both development and master doc	2022-09-23 14:14:10 +02:00
Ulrich Mohr	5488ee715f	testing deployment of documentation	2022-09-23 14:07:12 +02:00
Ulrich Mohr	0fea22d031	switching to rsync and deploying to web documentation	2022-09-23 14:06:28 +02:00
Ulrich Mohr	3b8ca09299	prepared docker for documentation rsync	2022-09-23 13:46:03 +02:00
Ulrich Mohr	9a2146fa2d	added impressum and datenschutz in sphinx documentation	2022-09-23 11:36:29 +02:00
Robin Müller	558550ecb9	Merge branch 'development' into mueller/smaller-tweaks	2022-09-16 18:37:39 +02:00
Robin Mueller	72172a972b	update changelog	2022-09-16 18:24:23 +02:00
Robin Mueller	b4b11ebd3b	fixes and tweaks	2022-09-16 18:20:42 +02:00
Robin Mueller	bcbbc9763a	markdown update not required, will be removed	2022-09-15 14:00:01 +02:00
Robin Mueller	0042372cb6	now that doc server is up, remove markdown files	2022-09-15 13:58:13 +02:00
Robin Mueller	8dea13742f	update rst file	2022-09-15 13:57:39 +02:00
Robin Mueller	0f027d29d2	doc corrections	2022-09-15 13:53:42 +02:00
Robin Mueller	131e3ff1e3	Revert "doc corrections" This reverts commit `423a9540ed`.	2022-09-15 13:52:28 +02:00
Robin Mueller	423a9540ed	doc corrections	2022-09-15 13:51:59 +02:00
Robin Mueller	ce7146e468	printout tweak	2022-09-15 13:40:12 +02:00
Robin Mueller	a681a4a797	better error printout	2022-09-15 13:38:38 +02:00
Robin Mueller	83b7b8707c	Merge remote-tracking branch 'origin/development' into mueller/refactor-accepts-tc-tm-if	2022-09-15 11:01:19 +02:00
Robin Müller	4002b74ea2	Merge branch 'development' into mueller/service-interface-include-correction	2022-09-15 11:01:06 +02:00
Robin Mueller	1a833e2d45	another missing changelog entry	2022-09-15 10:59:10 +02:00
Robin Mueller	8df6d934d7	another missing changelog entry	2022-09-15 10:56:52 +02:00
Robin Mueller	5363868120	added another missing changelog entry	2022-09-15 10:54:45 +02:00
Robin Mueller	8501477a78	Merge remote-tracking branch 'origin/development' into mueller/refactor-accepts-tc-tm-if	2022-09-15 10:48:42 +02:00
Robin Müller	6eea711d9f	Merge branch 'development' into mueller/service-interface-include-correction	2022-09-15 10:48:28 +02:00
Robin Mueller	9a181aa6a8	another missing changelog entry	2022-09-15 10:47:50 +02:00
Robin Mueller	655c944c0e	another missing changelog entry	2022-09-15 10:45:35 +02:00
Robin Mueller	2e310fca8d	add another missing changelog entry	2022-09-15 10:43:45 +02:00
Robin Mueller	37390dfc74	add missing changelog entry	2022-09-15 10:42:35 +02:00
Robin Mueller	1efc0d2855	update changelog	2022-09-15 10:38:40 +02:00
Robin Mueller	237e29cc59	all necessary modifications	2022-09-14 20:21:03 +02:00
Robin Mueller	0849c8a08d	adding files manually	2022-09-14 20:10:41 +02:00
Robin Mueller	9d626e0a5d	include correction	2022-09-14 19:59:02 +02:00
Robin Müller	0ce568ad26	Merge pull request 'publish documentation for development and master branch' (#681 ) from mohr/documentation_ci into development Reviewed-on: fsfw/fsfw#681	2022-09-14 11:22:35 +02:00
Ulrich Mohr	6970068d56	small fix in README	2022-09-13 18:19:35 +02:00
Ulrich Mohr	af282c7d3e	reverting to only publish development	2022-09-13 18:17:56 +02:00
Ulrich Mohr	21a9d89fb3	pushing code coverage report to documentation server	2022-09-13 18:14:26 +02:00
Ulrich Mohr	3257935150	fixing scp yet again again	2022-09-13 18:06:16 +02:00
Ulrich Mohr	f34cf9095d	fixing scp yet again	2022-09-13 18:02:38 +02:00
Ulrich Mohr	24ecf125a3	fixing scp command again	2022-09-13 17:55:12 +02:00
Ulrich Mohr	6451a16888	fixing scp command	2022-09-13 17:51:01 +02:00
Ulrich Mohr	fa5605c959	testing Jenkinsfile	2022-09-13 14:50:37 +02:00
Ulrich Mohr	8e835be55f	testing Jenkinsfile	2022-09-13 14:46:12 +02:00
Ulrich Mohr	9bd600c488	testing Jenkinsfile	2022-09-13 14:32:10 +02:00
Ulrich Mohr	9c7248e78e	typo in Dockerfile	2022-09-13 14:20:30 +02:00
Ulrich Mohr	ecf51b2913	testing Jenkinsfile	2022-09-13 14:09:08 +02:00
Ulrich Mohr	8bbde05413	add jenkins user in docker so that ssh will work	2022-09-13 14:08:04 +02:00
Ulrich Mohr	d79b5348d8	testing Jenkinsfile	2022-09-13 14:00:36 +02:00
Ulrich Mohr	92e3ab04f3	testing Jenkinsfile	2022-09-13 13:54:23 +02:00
Ulrich Mohr	003a6d00fa	Documentation build tools in docker	2022-09-13 13:13:18 +02:00
Ulrich Mohr	9ee1896553	Merge pull request 'Refactor Local Pool API' (#667 ) from mueller/refactor-local-pool-api into development Reviewed-on: fsfw/fsfw#667	2022-09-12 14:32:08 +02:00
Ulrich Mohr	a5b5523111	Merge pull request 'Refactor TMTC Stack, improve test framework' (#655 ) from mueller/refactor-tmtc-stack into development Reviewed-on: fsfw/fsfw#655	2022-09-12 14:31:22 +02:00
Ulrich Mohr	62cd39e573	Merge pull request 'SerialBufferAdapter refactoring' (#677 ) from mueller/refactor-serial-buffer-adapter into development Reviewed-on: fsfw/fsfw#677	2022-09-12 14:30:51 +02:00
Ulrich Mohr	278ed36db8	Merge pull request 'bump catch2 version' (#678 ) from mueller/bump-catch2 into development Reviewed-on: fsfw/fsfw#678	2022-09-12 14:24:28 +02:00
Ulrich Mohr	aed30d54ef	Merge pull request 'remove bsp specific code' (#679 ) from mueller/remove-bsp-specific-code into development Reviewed-on: fsfw/fsfw#679	2022-09-12 14:23:48 +02:00
Ulrich Mohr	1126db2c8a	Merge pull request 'remove user includes' (#675 ) from mueller/remove-user-includes into development Reviewed-on: fsfw/fsfw#675	2022-09-12 14:15:18 +02:00
Ulrich Mohr	a64a04d7fe	Merge branch 'development' into mueller/refactor-tmtc-stack	2022-09-12 14:14:49 +02:00
Robin Müller	80467bf097	Merge pull request 'sif::buffer: if disabeld do not print' (#680 ) from mohr/enableDisable into development Reviewed-on: fsfw/fsfw#680	2022-09-12 14:12:13 +02:00
Robin Müller	6a6aa7fdd6	Merge branch 'development' into mohr/enableDisable	2022-09-12 14:11:38 +02:00
Ulrich Mohr	7e379d2159	Merge pull request 'provide a weak print char impl' (#674 ) from mueller/provide-weak-print-char into development Reviewed-on: fsfw/fsfw#674	2022-09-12 14:10:31 +02:00
Robin Müller	6ae709acc3	Merge branch 'development' into mueller/remove-user-includes	2022-09-12 14:07:09 +02:00
Ulrich Mohr	d52f335455	sif::buffer: if disabeld do not print	2022-09-08 11:47:40 +02:00
Robin Mueller	04b619a15c	update header as well	2022-09-07 17:58:49 +02:00
Robin Mueller	282704e0fd	remove bsp specific code	2022-09-07 17:54:04 +02:00
Robin Mueller	07ef9a0ec3	bump catch2 version	2022-09-06 15:47:04 +02:00
Robin Mueller	80464f2a81	Merge branch 'mueller/refactor-serial-buffer-adapter' into mueller/refactor-tmtc-stack	2022-09-05 16:38:58 +02:00
Robin Mueller	16688316a8	rename setBuffer to setConstBuffer	2022-09-05 16:31:56 +02:00
Robin Mueller	3583e30ee6	rename const buf setter	2022-09-05 16:27:20 +02:00
Robin Mueller	1e395dc402	set buffer expects const pointer now	2022-09-05 16:25:02 +02:00
Robin Mueller	f5421e9abd	refactor tm helper	2022-09-05 16:10:06 +02:00
Robin Mueller	4c3f9feb93	explicit include	2022-09-05 16:06:24 +02:00
Robin Mueller	b7ed8ff390	Merge branch 'mueller/refactor-tmtc-stack' of https://egit.irs.uni-stuttgart.de/fsfw/fsfw into mueller/refactor-tmtc-stack	2022-09-05 16:02:41 +02:00
Robin Mueller	75dc7a405d	del data wrapper	2022-09-05 16:02:32 +02:00
Robin Mueller	b7a1f79d5b	update FSFWCnfig.h	2022-09-05 15:36:12 +02:00
Robin Mueller	f0b7a103d4	refactor ctors	2022-09-05 15:30:53 +02:00
Robin Müller	ee93f4a4ca	Merge branch 'development' into mueller/refactor-tmtc-stack	2022-09-05 14:46:51 +02:00
Robin Mueller	d64ad71529	Some improvements for time stamper API	2022-09-05 14:44:35 +02:00
Robin Müller	26bc80964e	Merge branch 'development' into mueller/provide-weak-print-char	2022-09-05 14:14:06 +02:00
Steffen Gaisser	eb03bf52a6	Merge pull request 'better warning for missing include paths' (#676 ) from mueller/better-missing-inc-path-warning into development Reviewed-on: fsfw/fsfw#676	2022-09-05 14:13:19 +02:00
Robin Mueller	80355910ee	better warning	2022-09-02 09:05:10 +02:00
Robin Mueller	04800df31e	another user-level-include	2022-09-02 09:04:37 +02:00
Robin Mueller	1e85cdadfd	remove user includes	2022-09-02 08:55:33 +02:00
Robin Mueller	ebc02673dd	provide a weak print char impl	2022-09-02 08:50:39 +02:00
Robin Mueller	9202c6c17f	Merge branch 'mueller/refactor-tmtc-stack' into mueller/refactor-local-pool-api	2022-09-01 17:51:50 +02:00
Robin Mueller	5f8c549993	Merge remote-tracking branch 'origin/development' into mueller/refactor-local-pool-api	2022-09-01 17:51:44 +02:00
Robin Mueller	04bff7a522	test fix	2022-09-01 17:51:09 +02:00
Robin Mueller	5c20cc804e	Merge remote-tracking branch 'origin/development' into mueller/refactor-tmtc-stack	2022-09-01 17:48:40 +02:00
Ulrich Mohr	eb8e236cd4	Merge pull request 'Bugfix for Space Packet Parser' (#673 ) from eive/fsfw:mueller/fixes-tmtc-server-sp-parser into development Reviewed-on: fsfw/fsfw#673	2022-09-01 14:12:16 +02:00
Ulrich Mohr	7dec45ccf2	Merge pull request 'Service 11 regression' (#670 ) from eive/fsfw:mueller/service-11-issues into development Reviewed-on: fsfw/fsfw#670	2022-09-01 11:59:18 +02:00
Ulrich Mohr	2b01e86f9c	one small additional precaution	2022-09-01 11:56:07 +02:00
Ulrich Mohr	60fd3d43c0	Merge pull request 'DHB TM handler alternative API raw buffer' (#671 ) from mueller/dhb-handle-device-tm-2 into development Reviewed-on: fsfw/fsfw#671	2022-09-01 11:22:17 +02:00
Robin Müller	67980cb592	Merge branch 'development' into mueller/fixes-tmtc-server-sp-parser	2022-09-01 11:21:02 +02:00
Ulrich Mohr	3010f2f925	Merge pull request 'DHB set action commander before buildCommandFromCommand' (#672 ) from eive/fsfw:mueller/dhb-set-action-commander-before-building-cmd into development Reviewed-on: fsfw/fsfw#672	2022-09-01 11:18:32 +02:00
Robin Mueller	01651f0521	more simplfications	2022-09-01 10:52:48 +02:00
Robin Mueller	c7f300671f	update header	2022-09-01 10:45:10 +02:00
Robin Mueller	7d3223d766	add comment blocks	2022-09-01 10:44:57 +02:00
Robin Mueller	7ae82a5cb4	do not cache previous recipient	2022-09-01 08:58:18 +02:00
Robin Mueller	28ecd0e5c6	bugfix for SP parser	2022-09-01 08:51:12 +02:00
Robin Mueller	7345c18b04	small fix which allows sending action reply immediately	2022-08-31 16:50:48 +02:00
Robin Mueller	64a7fde301	this is annoying	2022-08-30 15:19:01 +02:00
Robin Mueller	9131ca688b	make two helper functions protected	2022-08-30 15:01:10 +02:00