.clang-format

@@ -0,0 +1,7 @@
+---
+BasedOnStyle: Google
+IndentWidth: 2
+---
+Language: Cpp
+ColumnLimit: 100
+---

.gitignore

@@ -2,3 +2,5 @@
 .project
 .settings
 .metadata
+
+/build*

CMakeLists.txt

@@ -1,5 +1,12 @@
 cmake_minimum_required(VERSION 3.13)
 
+set(FSFW_VERSION 2)
+set(FSFW_SUBVERSION 0)
+set(FSFW_REVISION 0)
+
+# Add the cmake folder so the FindSphinx module is found
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+
 option(FSFW_GENERATE_SECTIONS
     "Generate function and data sections. Required to remove unused code" ON
 )
@@ -7,6 +14,12 @@ if(FSFW_GENERATE_SECTIONS)
     option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()
 
+option(FSFW_BUILD_UNITTESTS "Build unittest binary in addition to static library" OFF)
+option(FSFW_BUILD_DOCS "Build documentation with Sphinx and Doxygen" OFF)
+if(FSFW_BUILD_UNITTESTS)
+    option(FSFW_TESTS_GEN_COV "Generate coverage data for unittests" ON)
+endif()
+
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
 # Options to exclude parts of the FSFW from compilation.
 option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
@@ -26,11 +39,65 @@ option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
 option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 
 set(LIB_FSFW_NAME fsfw)
+set(FSFW_TEST_TGT fsfw-tests)
+set(FSFW_DUMMY_TGT fsfw-dummy)
+
+project(${LIB_FSFW_NAME})
 add_library(${LIB_FSFW_NAME})
+
+if(FSFW_BUILD_UNITTESTS)
+    message(STATUS "Building the FSFW unittests in addition to the static library")
+    # Check whether the user has already installed Catch2 first
+    find_package(Catch2 3)
+    # Not installed, so use FetchContent to download and provide Catch2
+    if(NOT Catch2_FOUND)
+        include(FetchContent)
+
+        FetchContent_Declare(
+            Catch2
+            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+            GIT_TAG        v3.0.0-preview3
+        )
+
+        FetchContent_MakeAvailable(Catch2)
+    endif()
+
+    set(FSFW_CONFIG_PATH tests/src/fsfw_tests/unit/testcfg)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/FSFWConfig.h.in FSFWConfig.h)
+    configure_file(tests/src/fsfw_tests/unit/testcfg/TestsConfig.h.in tests/TestsConfig.h)
+
+    project(${FSFW_TEST_TGT} CXX C)
+    add_executable(${FSFW_TEST_TGT})
+
+    if(FSFW_TESTS_GEN_COV)
+        message(STATUS "Generating coverage data for the library")
+        message(STATUS "Targets linking against ${LIB_FSFW_NAME} "
+            "will be compiled with coverage data as well"
+        )
+        include(FetchContent)
+        FetchContent_Declare(
+            cmake-modules
+            GIT_REPOSITORY https://github.com/bilke/cmake-modules.git
+        )
+        FetchContent_MakeAvailable(cmake-modules)
+        set(CMAKE_BUILD_TYPE "Debug")
+        list(APPEND CMAKE_MODULE_PATH ${cmake-modules_SOURCE_DIR})
+        include(CodeCoverage)
+    endif()
+endif()
+
 set(FSFW_CORE_INC_PATH "inc")
 
 set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)
 
+# Configure Files
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+
 if(NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 11)
     set(CMAKE_CXX_STANDARD_REQUIRED True)
@@ -63,29 +130,37 @@ endif()
 set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
 if(FSFW_OSAL MATCHES host)
-    set(OS_FSFW_NAME "Host")
+    set(FSFW_OS_NAME "Host")
     set(FSFW_OSAL_HOST ON)
 elseif(FSFW_OSAL MATCHES linux)
-    set(OS_FSFW_NAME "Linux")
+    set(FSFW_OS_NAME "Linux")
     set(FSFW_OSAL_LINUX ON)
 elseif(FSFW_OSAL MATCHES freertos)
-    set(OS_FSFW_NAME "FreeRTOS")
+    set(FSFW_OS_NAME "FreeRTOS")
     set(FSFW_OSAL_FREERTOS ON)
     target_link_libraries(${LIB_FSFW_NAME} PRIVATE
         ${LIB_OS_NAME}
     )
 elseif(FSFW_OSAL STREQUAL rtems)
-    set(OS_FSFW_NAME "RTEMS")
+    set(FSFW_OS_NAME "RTEMS")
     set(FSFW_OSAL_RTEMS ON)
 else()
     message(WARNING
         "Invalid operating system for FSFW specified! Setting to host.."
     )
-    set(OS_FSFW_NAME "Host")
+    set(FSFW_OS_NAME "Host")
     set(OS_FSFW "host")
 endif()
 
-message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
+if(FSFW_BUILD_UNITTESTS OR FSFW_BUILD_DOCS)
+    configure_file(src/fsfw/FSFW.h.in fsfw/FSFW.h)
+    configure_file(src/fsfw/FSFWVersion.h.in fsfw/FSFWVersion.h)
+else()
+    configure_file(src/fsfw/FSFW.h.in FSFW.h)
+    configure_file(src/fsfw/FSFWVersion.h.in FSFWVersion.h)
+endif()
+
+message(STATUS "Compiling FSFW for the ${FSFW_OS_NAME} operating system.")
 
 add_subdirectory(src)
 add_subdirectory(tests)
@@ -93,13 +168,87 @@ if(FSFW_ADD_HAL)
     add_subdirectory(hal)
 endif()
 add_subdirectory(contrib)
+if(FSFW_BUILD_DOCS)
+    add_subdirectory(docs)
+endif()
+
+if(FSFW_BUILD_UNITTESTS)
+    if(FSFW_TESTS_GEN_COV)
+        if(CMAKE_COMPILER_IS_GNUCXX)
+            include(CodeCoverage)
+
+            # Remove quotes.
+            separate_arguments(COVERAGE_COMPILER_FLAGS
+                NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}"
+            )
+
+            # Add compile options manually, we don't want coverage for Catch2
+            target_compile_options(${FSFW_TEST_TGT} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
+            target_compile_options(${LIB_FSFW_NAME} PRIVATE
+                "${COVERAGE_COMPILER_FLAGS}"
+            )
+
+            # Exclude directories here
+            if(WIN32)
+                set(GCOVR_ADDITIONAL_ARGS
+                    "--exclude-throw-branches"
+                    "--exclude-unreachable-branches"
+                )
+                set(COVERAGE_EXCLUDES
+                    "/c/msys64/mingw64/*"
+                )
+            elseif(UNIX)
+                set(COVERAGE_EXCLUDES
+                    "/usr/include/*" "/usr/bin/*" "Catch2/*"
+                    "/usr/local/include/*" "*/fsfw_tests/*"
+                    "*/catch2-src/*"
+                )
+            endif()
+
+            target_link_options(${FSFW_TEST_TGT} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            target_link_options(${LIB_FSFW_NAME} PRIVATE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+            # Need to specify this as an interface, otherwise there will the compile issues
+            target_link_options(${LIB_FSFW_NAME} INTERFACE
+                -fprofile-arcs
+                -ftest-coverage
+            )
+
+            if(WIN32)
+                setup_target_for_coverage_gcovr_html(
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
+            else()
+                setup_target_for_coverage_lcov(
+                    NAME ${FSFW_TEST_TGT}_coverage
+                    EXECUTABLE ${FSFW_TEST_TGT}
+                    DEPENDENCIES ${FSFW_TEST_TGT}
+                )
+            endif()
+        endif()
+    endif()
+    target_link_libraries(${FSFW_TEST_TGT} PRIVATE Catch2::Catch2 ${LIB_FSFW_NAME})
+endif()
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
 # If this is not given, we include the default configuration and emit a warning.
 if(NOT FSFW_CONFIG_PATH)
+    set(DEF_CONF_PATH misc/defaultcfg/fsfwconfig)
+    if(NOT FSFW_BUILD_DOCS)
         message(WARNING "Flight Software Framework configuration path not set!")
-	message(WARNING "Setting default configuration!")
+        message(WARNING "Setting default configuration from ${DEF_CONF_PATH} ..")
-	add_subdirectory(defaultcfg/fsfwconfig)
+    endif()
+    add_subdirectory(${DEF_CONF_PATH})
+    set(FSFW_CONFIG_PATH ${DEF_CONF_PATH})
 endif()
 
 # FSFW might be part of a possibly complicated folder structure, so we 
@@ -187,3 +336,16 @@ target_compile_options(${LIB_FSFW_NAME} PRIVATE
 target_link_libraries(${LIB_FSFW_NAME} PRIVATE
     ${FSFW_ADDITIONAL_LINK_LIBS}
 )
+
+string(CONCAT POST_BUILD_COMMENT
+    "######################################################################\n"
+    "Built FSFW v${FSFW_VERSION}.${FSFW_SUBVERSION}.${FSFW_REVISION}, "
+    "Target OSAL: ${FSFW_OS_NAME}\n"
+    "######################################################################\n"
+)
+
+add_custom_command(
+   TARGET ${LIB_FSFW_NAME}
+   POST_BUILD
+   COMMENT ${POST_BUILD_COMMENT}
+)

README.md

@@ -22,28 +22,107 @@ Currently, the FSFW provides the following OSALs:
 - FreeRTOS
 - RTEMS
 
-The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile Memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active satellite mission Flying Laptop.
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile
+memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a
+ISISPACE IOBC or a Zynq-7020 SoC. The `fsfw` was also successfully run on the
+STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active
+satellite mission Flying Laptop.
 
 ## Getting started
 
-The [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example) provides a good starting point and a demo to see the FSFW capabilities and build it with the Make or the CMake build system. It is recommended to evaluate the FSFW by building and playing around with the demo application.
+The [Hosted FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted) provides a
+good starting point and a demo to see the FSFW capabilities.
+It is recommended to get started by building and playing around with the demo application.
+There are also other examples provided for all OSALs using the popular embedded platforms
+Raspberry Pi, Beagle Bone Black and STM32H7.
 
-Generally, the FSFW is included in a project by compiling the FSFW sources and providing
+Generally, the FSFW is included in a project by providing
-a configuration folder and adding it to the include path. There are some functions like `printChar` which are different depending on the target architecture and need to be implemented by the mission developer.
+a configuration folder, building the static library and linking against it. 
+There are some functions like `printChar` which are different depending on the target architecture
+and need to be implemented by the mission developer.
 
 A template configuration folder was provided and can be copied into the project root to have
-a starting point. The [configuration section](doc/README-config.md#top) provides more specific information about the possible options.
+a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
+information about the possible options.
+
+## Adding the library
+
+The following steps show how to add and use FSFW components. It is still recommended to
+try out the example mentioned above to get started, but the following steps show how to
+add and link against the FSFW library in general.
+
+1. Add this repository as a submodule
+
+   ```sh
+   git submodule add https://egit.irs.uni-stuttgart.de/fsfw/fsfw.git fsfw   
+   ```
+
+2. Add the following directive inside the uppermost `CMakeLists.txt` file of your project
+
+   ```cmake
+   add_subdirectory(fsfw)
+   ```
+
+3. Make sure to provide a configuration folder and supply the path to that folder with
+   the `FSFW_CONFIG_PATH` CMake variable from the uppermost `CMakeLists.txt` file.
+   It is also necessary to provide the `printChar` function. You can find an example
+   implementation for a hosted build 
+   [here](https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted/src/branch/master/bsp_hosted/utility/printChar.c).
+
+4. Link against the FSFW library
+
+	```cmake
+	target_link_libraries(<YourProjectName> PRIVATE fsfw)
+	```
+
+5. It should now be possible use the FSFW as a static library from the user code.
+
+## Building the unittests
+
+The FSFW also has unittests which use the [Catch2 library](https://github.com/catchorg/Catch2).
+These are built by setting the CMake option `FSFW_BUILD_UNITTESTS` to `ON` or `TRUE`
+from your project `CMakeLists.txt` file or from the command line.
+
+The fsfw-tests binary will be built as part of the static library and dropped alongside it.
+If the unittests are built, the library and the tests will be built with coverage information by
+default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
+
+You can use the following commands inside the `fsfw` folder to set up the build system
+
+```sh
+mkdir build-Unittest && cd build-Unittest
+cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
+```
+
+You can also use `-DFSFW_OSAL=linux` on Linux systems.
+
+Coverage data in HTML format can be generated using the `CodeCoverage`
+[CMake module](https://github.com/bilke/cmake-modules/tree/master).
+To build the unittests, run them and then generare the coverage data in this format,
+the following command can be used inside the build directory after the build system was set up
+
+```sh
+cmake --build . -- fsfw-tests_coverage -j
+```
+
+The `coverage.py` script located in the `script` folder can also be used to do this conveniently.
+
+## Formatting the sources
+
+The formatting is done by the `clang-format` tool. The configuration is contained within the
+`.clang-format` file in the repository root. As long as `clang-format` is installed, you
+can run the `apply-clang-format.sh` helper script to format all source files consistently.
 
 ## Index
 
-[1. High-level overview](doc/README-highlevel.md#top) <br>
+[1. High-level overview](docs/README-highlevel.md#top) <br>
-[2. Core components](doc/README-core.md#top) <br>
+[2. Core components](docs/README-core.md#top) <br>
-[3. Configuration](doc/README-config.md#top) <br>
+[3. Configuration](docs/README-config.md#top) <br>
-[4. OSAL overview](doc/README-osal.md#top) <br>
+[4. OSAL overview](docs/README-osal.md#top) <br>
-[5. PUS services](doc/README-pus.md#top) <br>
+[5. PUS services](docs/README-pus.md#top) <br>
-[6. Device Handler overview](doc/README-devicehandlers.md#top) <br>
+[6. Device Handler overview](docs/README-devicehandlers.md#top) <br>
-[7. Controller overview](doc/README-controllers.md#top) <br>
+[7. Controller overview](docs/README-controllers.md#top) <br>
-[8. Local Data Pools](doc/README-localpools.md#top) <br>
+[8. Local Data Pools](docs/README-localpools.md#top) <br>
 
 
 

automation/Dockerfile

@@ -0,0 +1,8 @@
+FROM ubuntu:focal
+
+RUN apt-get update
+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

automation/Jenkinsfile

@@ -0,0 +1,72 @@
+pipeline {
+    agent any
+    environment {
+        BUILDDIR = 'build-unittests'
+    }
+    stages {
+        stage('Create Docker') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    additionalBuildArgs  '--no-cache'
+                    reuseNode true
+                }
+            }
+            steps {
+                sh 'rm -rf $BUILDDIR'
+            }
+        }
+        stage('Configure') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    reuseNode true
+                }
+            }
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..'
+                }
+            }
+        }
+        stage('Build') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    reuseNode true
+                }
+            }
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake --build . -j'
+                }
+            }
+        }
+        stage('Unittests') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    reuseNode true
+                }
+            }
+            steps {
+                dir(BUILDDIR) {
+                    sh 'cmake --build . -- fsfw-tests_coverage -j'
+                }
+            }
+        }
+        stage('Valgrind') {
+            agent {
+                dockerfile {
+                    dir 'automation'
+                    reuseNode true
+                }
+            }
+            steps {
+                dir(BUILDDIR) {
+                    sh 'valgrind --leak-check=full --error-exitcode=1 ./fsfw-tests'
+                }
+            }
+        }
+    }
+}

cmake/FindSphinx.cmake

@@ -0,0 +1,13 @@
+# Look for an executable called sphinx-build
+find_program(SPHINX_EXECUTABLE
+             NAMES sphinx-build
+             DOC "Path to sphinx-build executable")
+
+include(FindPackageHandleStandardArgs)
+
+# Handle standard arguments to find_package like REQUIRED and QUIET
+find_package_handle_standard_args(
+    Sphinx
+    "Failed to find sphinx-build executable"
+    SPHINX_EXECUTABLE
+)

docs/.gitignore

@@ -0,0 +1 @@
+/_build

docs/CMakeLists.txt

@@ -0,0 +1,66 @@
+# This is based on this excellent posting provided by Sy: 
+# https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/
+find_package(Doxygen REQUIRED)
+find_package(Sphinx REQUIRED)
+
+get_target_property(LIB_FSFW_PUBLIC_HEADER_DIRS ${LIB_FSFW_NAME} INTERFACE_INCLUDE_DIRECTORIES)
+# TODO: Add HAL as well
+file(GLOB_RECURSE LIB_FSFW_PUBLIC_HEADERS ${PROJECT_SOURCE_DIR}/src/*.h)
+file(GLOB_RECURSE RST_DOC_FILES ${PROJECT_SOURCE_DIR}/docs/*.rst)
+
+set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR}/src)
+set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/doxygen)
+set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/xml/index.xml)
+set(DOXYFILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in)
+set(DOXYFILE_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+
+# Replace variables inside @@ with the current values
+configure_file(${DOXYFILE_IN} ${DOXYFILE_OUT} @ONLY)
+
+# Doxygen won't create this for us
+file(MAKE_DIRECTORY ${DOXYGEN_OUTPUT_DIR})
+
+# Only regenerate Doxygen when the Doxyfile or public headers change
+add_custom_command(
+  OUTPUT ${DOXYGEN_INDEX_FILE}
+  DEPENDS ${LIB_FSFW_PUBLIC_HEADERS}
+  COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE_OUT}
+  MAIN_DEPENDENCY ${DOXYFILE_OUT} ${DOXYFILE_IN}
+  COMMENT "Generating docs"
+  VERBATIM
+)
+
+# Nice named target so we can run the job easily
+add_custom_target(Doxygen ALL DEPENDS ${DOXYGEN_INDEX_FILE})
+
+set(SPHINX_SOURCE ${CMAKE_CURRENT_SOURCE_DIR})
+set(SPHINX_BUILD ${CMAKE_CURRENT_BINARY_DIR}/sphinx)
+set(SPHINX_INDEX_FILE ${SPHINX_BUILD}/index.html)
+
+# Only regenerate Sphinx when:
+# - Doxygen has rerun
+# - Our doc files have been updated
+# - The Sphinx config has been updated
+add_custom_command(
+  OUTPUT ${SPHINX_INDEX_FILE}
+  COMMAND
+    ${SPHINX_EXECUTABLE} -b html
+    # Tell Breathe where to find the Doxygen output
+    -Dbreathe_projects.fsfw=${DOXYGEN_OUTPUT_DIR}/xml
+  ${SPHINX_SOURCE} ${SPHINX_BUILD}
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+  DEPENDS
+  # Other docs files you want to track should go here (or in some variable)
+  ${RST_DOC_FILES}
+  ${DOXYGEN_INDEX_FILE}
+  MAIN_DEPENDENCY ${SPHINX_SOURCE}/conf.py
+  COMMENT "Generating documentation with Sphinx"
+)
+
+# Nice named target so we can run the job easily
+add_custom_target(Sphinx ALL DEPENDS ${SPHINX_INDEX_FILE})
+
+# Add an install target to install the docs
+include(GNUInstallDirs)
+install(DIRECTORY ${SPHINX_BUILD}
+DESTINATION ${CMAKE_INSTALL_DOCDIR})

docs/Doxyfile.in

@@ -0,0 +1,7 @@
+INPUT = "@DOXYGEN_INPUT_DIR@"
+
+RECURSIVE = YES
+
+OUTPUT_DIRECTORY = "@DOXYGEN_OUTPUT_DIR@"
+
+GENERATE_XML = YES

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/README-localpools.md

@@ -31,7 +31,9 @@ cohesive pool variables. These sets simply iterator over the list of variables a
 `read` and `commit` functions of each variable. The following diagram shows the
 high-level architecture of the local data pools.
 
-<img align="center" src="./images/PoolArchitecture.png" width="50%"> <br>
+.. 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

docs/api.rst

@@ -0,0 +1,16 @@
+API
+====
+
+.. toctree::
+   :maxdepth: 4
+
+   api/objectmanager
+   api/task
+   api/ipc
+   api/returnvalue
+   api/event
+   api/modes
+   api/health
+   api/action
+   api/devicehandler
+   api/controller

docs/api/action.rst

@@ -0,0 +1,15 @@
+Action Module API
+=================
+
+``ActionHelper``
+-----------------
+
+.. doxygenclass:: ActionHelper
+	:members:
+
+``HasActionsIF``
+-----------------
+
+.. doxygenclass:: HasActionsIF
+	:members:
+	:protected-members:

docs/api/controller.rst

@@ -0,0 +1,16 @@
+Controller API
+=================
+
+``ControllerBase``
+-------------------------
+
+.. doxygenclass:: ControllerBase
+	:members:
+	:protected-members:
+
+``ExtendedControllerBase``
+-----------------------------
+
+.. doxygenclass:: ExtendedControllerBase
+	:members:
+	:protected-members:

docs/api/devicehandler.rst

@@ -0,0 +1,16 @@
+Device Handler Base API
+=========================
+
+``DeviceHandlerBase``
+-----------------------
+
+.. doxygenclass:: DeviceHandlerBase
+	:members:
+	:protected-members:
+
+``DeviceHandlerIF``
+-----------------------
+
+.. doxygenclass:: DeviceHandlerIF
+	:members:
+	:protected-members:

docs/api/event.rst

@@ -0,0 +1,6 @@
+.. _eventapi:
+
+Event API
+============
+
+.. doxygenfile:: Event.h

docs/api/health.rst

@@ -0,0 +1,9 @@
+Health API
+===========
+
+``HasHealthIF``
+------------------
+
+.. doxygenclass:: HasHealthIF
+	:members:
+	:protected-members:

docs/api/ipc.rst

@@ -0,0 +1,9 @@
+IPC Module API
+=================
+
+``MessageQueueIF``
+-------------------
+
+.. doxygenclass:: MessageQueueIF
+	:members:
+	:protected-members:

docs/api/modes.rst

@@ -0,0 +1,10 @@
+Modes API
+=========
+
+
+``HasModesIF``
+---------------
+
+.. doxygenclass:: HasModesIF
+	:members:
+	:protected-members:

docs/api/objectmanager.rst

@@ -0,0 +1,30 @@
+Object Manager API
+=========================
+
+``SystemObject``
+--------------------
+
+.. doxygenclass:: SystemObject
+	:members:
+	:protected-members:
+
+``ObjectManager``
+-----------------------
+
+.. doxygenclass:: ObjectManager
+	:members:
+	:protected-members:
+
+``SystemObjectIF``
+--------------------
+
+.. doxygenclass:: SystemObjectIF
+	:members:
+	:protected-members:
+
+``ObjectManagerIF``
+-----------------------
+
+.. doxygenclass:: ObjectManagerIF
+	:members:
+	:protected-members:

docs/api/returnvalue.rst

@@ -0,0 +1,10 @@
+.. _retvalapi:
+
+Returnvalue API
+==================
+
+.. doxygenfile:: HasReturnvaluesIF.h
+
+.. _fwclassids:
+
+.. doxygenfile:: FwClassIds.h

docs/api/task.rst

@@ -0,0 +1,8 @@
+Task API
+=========
+
+``ExecutableObjectIF``
+-----------------------
+
+.. doxygenclass:: ExecutableObjectIF
+	:members:

docs/conf.py

@@ -0,0 +1,56 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'Flight Software Framework'
+copyright = '2021, Institute of Space Systems (IRS)'
+author = 'Institute of Space Systems (IRS)'
+
+# The full version, including alpha/beta/rc tags
+release = '2.0.1'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [ "breathe" ]
+
+breathe_default_project = "fsfw"
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# 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".
+html_static_path = []

docs/config.rst

@@ -0,0 +1,41 @@
+Configuring the FSFW
+=====================
+
+The FSFW can be configured via the ``fsfwconfig`` folder. A template folder has been provided in
+``misc/defaultcfg`` 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
+   `fsfwgen Python scripts <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-gen>`_.
+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/develop/generators>`_
+or the `FSFW example <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted/src/branch/master/generators>`_
+
+Configuring the Event Manager
+----------------------------------
+
+The number of allowed subscriptions can be modified with the following
+parameters:
+
+.. code-block:: cpp
+
+   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;
+   }

docs/controllers.rst

@@ -0,0 +1,2 @@
+Controllers
+=============

docs/core.rst

@@ -0,0 +1,70 @@
+.. _core:
+
+Core Modules
+=============
+
+The 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
+
+Object Manager
+---------------
+
+- Must be created during program startup
+- The component which handles all references. All :cpp:class:`SystemObject`\s register at this
+  component.
+- All :cpp:class:`SystemObject`\s needs to have a unique Object ID. Those can be managed like
+  framework objects.
+- A reference to an object can be retrieved by calling the ``get`` function of
+  :cpp:class:`ObjectManagerIF`. The target type must be specified as a template argument.
+  A ``nullptr`` check of the returning pointer must be done. This function is based on
+  run-time type information.
+
+	.. code-block:: 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::instance()->initialize(produceFunc)`` the
+  produce function will be called and all :cpp:class:`SystemObject`\s 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
+

docs/devicehandlers.rst

@@ -0,0 +1,3 @@
+Device Handlers
+==================
+

docs/getting_started.rst

@@ -0,0 +1,115 @@
+Getting Started
+================
+
+
+Getting started
+----------------
+
+The `Hosted FSFW example`_ provides a good starting point and a demo to see the FSFW capabilities.
+It is recommended to get started by building and playing around with the demo application.
+There are also other examples provided for all OSALs using the popular embedded platforms
+Raspberry Pi, Beagle Bone Black and STM32H7.
+
+Generally, the FSFW is included in a project by providing
+a configuration folder, building the static library and linking against it. 
+There are some functions like ``printChar`` which are different depending on the target architecture
+and need to be implemented by the mission developer.
+
+A template configuration folder was provided and can be copied into the project root to have
+a starting point. The [configuration section](docs/README-config.md#top) provides more specific 
+information about the possible options.
+
+Adding the library
+-------------------
+
+The following steps show how to add and use FSFW components. It is still recommended to
+try out the example mentioned above to get started, but the following steps show how to
+add and link against the FSFW library in general.
+
+1. Add this repository as a submodule
+
+   .. code-block:: console
+
+      git submodule add https://egit.irs.uni-stuttgart.de/fsfw/fsfw.git fsfw
+
+2. Add the following directive inside the uppermost ``CMakeLists.txt`` file of your project
+
+   .. code-block:: cmake
+
+      add_subdirectory(fsfw)
+
+3. Make sure to provide a configuration folder and supply the path to that folder with
+   the `FSFW_CONFIG_PATH` CMake variable from the uppermost `CMakeLists.txt` file.
+   It is also necessary to provide the `printChar` function. You can find an example
+   implementation for a hosted build
+   `here <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted/src/branch/master/bsp_hosted/utility/printChar.c>`_.
+
+4. Link against the FSFW library
+
+   .. code-block:: cmake
+
+      target_link_libraries(<YourProjectName> PRIVATE fsfw)
+
+
+5. It should now be possible use the FSFW as a static library from the user code.
+
+Building the unittests
+-------------------------
+
+The FSFW also has unittests which use the `Catch2 library`_.
+These are built by setting the CMake option ``FSFW_BUILD_UNITTESTS`` to ``ON`` or `TRUE`
+from your project `CMakeLists.txt` file or from the command line.
+
+The fsfw-tests binary will be built as part of the static library and dropped alongside it.
+If the unittests are built, the library and the tests will be built with coverage information by
+default. This can be disabled by setting the `FSFW_TESTS_COV_GEN` option to `OFF` or `FALSE`.
+
+You can use the following commands inside the ``fsfw`` folder to set up the build system
+
+.. code-block:: console
+
+   mkdir build-tests && cd build-tests
+   cmake -DFSFW_BUILD_UNITTESTS=ON -DFSFW_OSAL=host ..
+
+
+You can also use ``-DFSFW_OSAL=linux`` on Linux systems.
+
+Coverage data in HTML format can be generated using the `Code coverage`_ CMake module.
+To build the unittests, run them and then generare the coverage data in this format,
+the following command can be used inside the build directory after the build system was set up
+
+.. code-block:: console
+
+   cmake --build . -- fsfw-tests_coverage -j
+
+
+The ``helper.py`` script located in the ``script`` folder can also be used to create, build
+and open the unittests conveniently. Try ``helper.py -h`` for more information.
+
+Building the documentation
+----------------------------
+
+The FSFW documentation is built using the tools Sphinx, doxygen and breathe based on the
+instructions provided in `this blogpost <https://devblogs.microsoft.com/cppblog/clear-functional-c-documentation-with-sphinx-breathe-doxygen-cmake/>`_. You can set up a
+documentation build system using the following commands
+
+.. code-block:: bash
+
+   mkdir build-docs && cd build-docs
+   cmake -DFSFW_BUILD_DOCS=ON -DFSFW_OSAL=host ..
+
+Then you can generate the documentation using
+
+.. code-block:: bash
+
+   cmake --build . -j
+
+You can find the generated documentation inside the ``docs/sphinx`` folder inside the build
+folder. Simply open the ``index.html`` in the webbrowser of your choice.
+
+The ``helper.py`` script located in the ``script`` folder can also be used to create, build
+and open the documentation conveniently. Try ``helper.py -h`` for more information.
+
+.. _`Hosted FSFW example`: https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted
+.. _`Catch2 library`: https://github.com/catchorg/Catch2
+.. _`Code coverage`: https://github.com/bilke/cmake-modules/tree/master

docs/highlevel.rst

@@ -0,0 +1,149 @@
+.. _highlevel:
+
+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 :cpp:type:`ReturnValue_t` to signal to the caller that something has
+gone wrong. Returnvalues must be unique. For this the function :cpp:func:`HasReturnvaluesIF::makeReturnCode`
+or the :ref:`macro MAKE_RETURN_CODE <retvalapi>` can be used. The ``CLASS_ID`` is a unique ID for that type of object.
+See the :ref:`FSFW Class IDs file <fwclassids>`. 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 :ref:`OSAL README <osal>` 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
+:ref:`core component section <core>`:
+
+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.
+4. Clock: This module provided common time related functions
+5. EventManager: This module allows routing of events generated by `SystemObjects`
+6. 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 ``misc/defaultcfg/fsfwconfig/objects``
+inside the function ``Factory::setStaticFrameworkObjectIds``.
+
+Events
+----------------
+
+Events are tied to objects. EventIds can be generated by calling the
+:ref:`macro MAKE_EVENT <eventapi>` or the function :cpp:func:`event::makeEvent`.
+This works analog to the returnvalues. Every object that needs own Event IDs has to get a
+unique ``SUBSYSTEM_ID``. Every :cpp:class:`SystemObject` can call
+:cpp:func:`SystemObject::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/robamu-org/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.
+
+- Device handlers 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 top level subsystem components
+- The top level subsystem components are used to group assemblies, controllers and device handlers.
+  For example, a spacecraft can have a atttitude control subsystem and a power subsystem.
+
+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.

docs/index.rst

@@ -0,0 +1,69 @@
+.. Flight Software Framework documentation master file, created by
+   sphinx-quickstart on Tue Nov 30 10:56:03 2021.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Flight Software Framework (FSFW) documentation
+================================================
+
+.. image:: ../misc/logo/FSFW_Logo_V3_bw.png
+   :alt: FSFW Logo
+
+The Flight Software Framework is a C++ Object Oriented Framework for unmanned,
+automated systems like Satellites. 
+
+The initial version of the Flight Software Framework was developed during
+the Flying Laptop Project by the University of Stuttgart in cooperation
+with Airbus Defence and Space GmbH.
+
+Quick facts
+---------------
+
+The framework is designed for systems, which communicate with external devices, perform control
+loops, receive telecommands and send telemetry, and need to maintain a high level of availability.
+Therefore, a mode and health system provides control over the states of the software and the
+controlled devices. In addition, a simple mechanism of event based fault detection, isolation and
+recovery is implemented as well.
+
+The FSFW provides abstraction layers for operating systems to provide a uniform operating system
+abstraction layer (OSAL). Some components of this OSAL are required internally by the FSFW but is
+also very useful for developers to implement the same application logic on different operating
+systems with a uniform interface.
+
+Currently, the FSFW provides the following OSALs:
+
+- Linux
+- Host 
+- FreeRTOS
+- RTEMS
+
+The recommended hardware is a microprocessor with more than 1 MB of RAM and 1 MB of non-volatile
+memory. For reference, current applications use a Cobham Gaisler UT699 (LEON3FT), a
+ISISPACE IOBC or a Zynq-7020 SoC. The ``fsfw`` was also successfully run on the
+STM32H743ZI-Nucleo board and on a Raspberry Pi and is currently running on the active
+satellite mission Flying Laptop.
+
+Index
+-------
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   getting_started
+   highlevel
+   core
+   config
+   osal
+   pus
+   devicehandlers
+   controllers
+   localpools
+   api
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

docs/localpools.rst

@@ -0,0 +1,181 @@
+Local Data Pools
+=========================================
+
+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:: ../docs/images/PoolArchitecture.png
+	:alt: Pool Architecture
+
+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:
+
+.. code-block:: 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, the ``GyroHandler`` will now have the set class
+as a member:
+
+.. code-block:: 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:
+
+.. code-block:: 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:
+
+.. code-block:: 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.
+
+.. code-block:: 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 HasReturnvaluesIF::RETURN_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:
+
+.. code-block:: cpp
+
+	PoolReadGuard readHelper(&gyroData);
+	if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_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
+
+

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/osal.rst

@@ -0,0 +1,63 @@
+.. _osal:
+
+Operating System Abstraction Layer (OSAL)
+============================================
+
+Some specific information on the provided OSALs are provided.
+
+Linux
+-------
+
+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.
+
+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.
+
+Example Applications
+----------------------
+
+There are example applications available for each OSAL
+
+- `Hosted OSAL <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-hosted>`_
+- `Linux OSAL for MCUs <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-linux-mcu>`_
+- `FreeRTOS OSAL on the STM32H743ZIT <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-stm32h7-freertos>`_
+- `RTEMS OSAL on the STM32H743ZIT <https://egit.irs.uni-stuttgart.de/fsfw/fsfw-example-stm32h7-rtems>`_

docs/pus.rst

@@ -0,0 +1,2 @@
+PUS Services
+==============

hal/src/fsfw_hal/common/gpio/gpioDefinitions.h

@@ -9,12 +9,13 @@ using gpioId_t = uint16_t;
 
 namespace gpio {
 
-enum Levels {
+enum Levels: uint8_t {
     LOW = 0,
-    HIGH = 1
+    HIGH = 1,
+    NONE = 99
 };
 
-enum Direction {
+enum Direction: uint8_t {
     IN = 0,
     OUT = 1
 };
@@ -24,16 +25,18 @@ enum GpioOperation {
     WRITE
 };
 
-enum GpioTypes {
+enum class GpioTypes {
     NONE,
     GPIO_REGULAR_BY_CHIP,
     GPIO_REGULAR_BY_LABEL,
+    GPIO_REGULAR_BY_LINE_NAME,
     CALLBACK
 };
 
 static constexpr gpioId_t NO_GPIO = -1;
 
-using gpio_cb_t = void (*) (gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args);
+using gpio_cb_t = void (*) (gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
+        void* args);
 
 }
 
@@ -57,7 +60,7 @@ public:
     GpioBase() = default;
 
     GpioBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
-            int initValue):
+            gpio::Levels initValue):
             gpioType(gpioType), consumer(consumer),direction(direction), initValue(initValue) {}
 
     virtual~ GpioBase() {};
@@ -66,15 +69,21 @@ public:
     gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
     std::string consumer;
     gpio::Direction direction = gpio::Direction::IN;
-    int initValue = 0;
+    gpio::Levels initValue = gpio::Levels::NONE;
 };
 
 class GpiodRegularBase: public GpioBase {
 public:
     GpiodRegularBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
-            int initValue, int lineNum): GpioBase(gpioType, consumer, direction, initValue),
+            gpio::Levels initValue, int lineNum):
-            lineNum(lineNum) {
+            GpioBase(gpioType, consumer, direction, initValue), lineNum(lineNum) {
     }
+
+    // line number will be configured at a later point for the open by line name configuration
+    GpiodRegularBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
+            gpio::Levels initValue): GpioBase(gpioType, consumer, direction, initValue) {
+    }
+
     int lineNum = 0;
     struct gpiod_line* lineHandle = nullptr;
 };
@@ -87,7 +96,7 @@ public:
     }
 
     GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
-            gpio::Direction direction_, int initValue_) :
+            gpio::Direction direction_, gpio::Levels initValue_) :
             GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP,
                     consumer_, direction_, initValue_, lineNum_),
             chipname(chipname_){
@@ -105,7 +114,7 @@ public:
 class GpiodRegularByLabel: public GpiodRegularBase {
 public:
     GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_,
-            gpio::Direction direction_, int initValue_) :
+            gpio::Direction direction_, gpio::Levels initValue_) :
             GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_,
                     direction_, initValue_, lineNum_),
             label(label_) {
@@ -120,9 +129,30 @@ public:
     std::string label;
 };
 
+/**
+ * @brief   Passing this GPIO configuration to the GPIO IF object will try to open the GPIO by its
+ *          line name. This line name can be set in the device tree and must be unique. Otherwise
+ *          the driver will open the first line with the given name.
+ */
+class GpiodRegularByLineName: public GpiodRegularBase {
+public:
+    GpiodRegularByLineName(std::string lineName_, std::string consumer_, gpio::Direction direction_,
+            gpio::Levels initValue_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_, direction_,
+                    initValue_), lineName(lineName_) {
+    }
+
+    GpiodRegularByLineName(std::string lineName_, std::string consumer_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME, consumer_,
+                    gpio::Direction::IN, gpio::LOW), lineName(lineName_) {
+    }
+
+    std::string lineName;
+};
+
 class GpioCallback: public GpioBase {
 public:
-    GpioCallback(std::string consumer, gpio::Direction direction_, int initValue_,
+    GpioCallback(std::string consumer, gpio::Direction direction_, gpio::Levels initValue_,
             gpio::gpio_cb_t callback, void* callbackArgs):
             GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
             callback(callback), callbackArgs(callbackArgs) {}

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -73,7 +73,7 @@ ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(
     switch (internalState) {
     case(InternalState::STATE_NONE):
     case(InternalState::STATE_NORMAL): {
-        return HasReturnvaluesIF::RETURN_OK;
+        return DeviceHandlerBase::NOTHING_TO_SEND;
     }
     case(InternalState::STATE_FIRST_CONTACT): {
         *id = MGMLIS3MDL::IDENTIFY_DEVICE;

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -186,7 +186,7 @@ ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const
         uint8_t cmmValue = packet[1];
         // We clear the seventh bit in any case
         // because this one is zero sometimes for some reason
-        bitutil::bitClear(&cmmValue, 6);
+        bitutil::clear(&cmmValue, 6);
         if(cmmValue == cmmRegValue and internalState == InternalState::READ_CMM) {
             commandExecuted = true;
         }

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.cpp

@@ -1,8 +1,9 @@
-#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "LinuxLibgpioIF.h"
+
 #include "fsfw_hal/common/gpio/gpioDefinitions.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
 
-#include <fsfw/serviceinterface/ServiceInterface.h>
+#include "fsfw/serviceinterface/ServiceInterface.h"
 
 #include <utility>
 #include <unistd.h>
@@ -66,6 +67,14 @@ ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
             configureGpioByLabel(gpioConfig.first, *regularGpio);
             break;
         }
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME):{
+            auto regularGpio = dynamic_cast<GpiodRegularByLineName*>(gpioConfig.second);
+            if(regularGpio == nullptr) {
+                return GPIO_INVALID_INSTANCE;
+            }
+            configureGpioByLineName(gpioConfig.first, *regularGpio);
+            break;
+        }
         case(gpio::GpioTypes::CALLBACK): {
             auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
             if(gpioCallback->callback == nullptr) {
@@ -84,13 +93,13 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
     std::string& label = gpioByLabel.label;
     struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
     if (chip == nullptr) {
-        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open gpio from gpio "
+        sif::warning << "LinuxLibgpioIF::configureGpioByLabel: Failed to open gpio from gpio "
                 << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
         return RETURN_FAILED;
 
     }
     std::string failOutput = "label: " + label;
-    return configureRegularGpio(gpioId, gpioByLabel.gpioType, chip, gpioByLabel, failOutput);
+    return configureRegularGpio(gpioId, chip, gpioByLabel, failOutput);
 }
 
 ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId,
@@ -98,16 +107,41 @@ ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId,
     std::string& chipname = gpioByChip.chipname;
     struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
     if (chip == nullptr) {
-        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open chip "
+        sif::warning << "LinuxLibgpioIF::configureGpioByChip: Failed to open chip "
                 << chipname << ". Gpio ID: " << gpioId << std::endl;
         return RETURN_FAILED;
     }
     std::string failOutput = "chipname: " + chipname;
-    return configureRegularGpio(gpioId, gpioByChip.gpioType, chip, gpioByChip, failOutput);
+    return configureRegularGpio(gpioId, chip, gpioByChip, failOutput);
 }
 
-ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+ReturnValue_t LinuxLibgpioIF::configureGpioByLineName(gpioId_t gpioId,
-        struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput) {
+        GpiodRegularByLineName &gpioByLineName) {
+    std::string& lineName = gpioByLineName.lineName;
+    char chipname[MAX_CHIPNAME_LENGTH];
+    unsigned int lineOffset;
+
+    int result = gpiod_ctxless_find_line(lineName.c_str(), chipname, MAX_CHIPNAME_LENGTH,
+            &lineOffset);
+    if (result != LINE_FOUND) {
+        parseFindeLineResult(result, lineName);
+        return RETURN_FAILED;
+    }
+
+    gpioByLineName.lineNum = static_cast<int>(lineOffset);
+
+    struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname);
+    if (chip == nullptr) {
+        sif::warning << "LinuxLibgpioIF::configureGpioByLineName: Failed to open chip "
+                << chipname << ". <Gpio ID: " << gpioId << std::endl;
+        return RETURN_FAILED;
+    }
+    std::string failOutput = "line name: " + lineName;
+    return configureRegularGpio(gpioId, chip, gpioByLineName, failOutput);
+}
+
+ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, struct gpiod_chip* chip,
+        GpiodRegularBase& regularGpio, std::string failOutput) {
     unsigned int lineNum;
     gpio::Direction direction;
     std::string consumer;
@@ -132,22 +166,10 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, gpio::GpioTy
     case(gpio::OUT): {
         result = gpiod_line_request_output(lineHandle, consumer.c_str(),
                 regularGpio.initValue);
-        if (result < 0) {
-            sif::error << "LinuxLibgpioIF::configureRegularGpio: Failed to request line " << lineNum <<
-                    " from GPIO instance with ID: " << gpioId << std::endl;
-            gpiod_line_release(lineHandle);
-            return RETURN_FAILED;
-        }
         break;
     }
     case(gpio::IN): {
         result = gpiod_line_request_input(lineHandle, consumer.c_str());
-        if (result < 0) {
-            sif::error << "LinuxLibgpioIF::configureGpios: Failed to request line "
-                    << lineNum << " from GPIO instance with ID: " << gpioId << std::endl;
-            gpiod_line_release(lineHandle);
-            return RETURN_FAILED;
-        }
         break;
     }
     default: {
@@ -156,6 +178,18 @@ ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, gpio::GpioTy
         return GPIO_INVALID_INSTANCE;
     }
 
+    if (result < 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "LinuxLibgpioIF::configureRegularGpio: Failed to request line " <<
+                lineNum << " from GPIO instance with ID: " << gpioId << std::endl;
+#else
+        sif::printError("LinuxLibgpioIF::configureRegularGpio: "
+                "Failed to request line %d from GPIO instance with ID: %d\n", lineNum, gpioId);
+#endif
+        gpiod_line_release(lineHandle);
+        return RETURN_FAILED;
+    }
+
     }
     /**
      * Write line handle to GPIO configuration instance so it can later be used to set or
@@ -173,8 +207,9 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
     }
 
     auto gpioType = gpioMapIter->second->gpioType;
-    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -187,7 +222,7 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
             return GPIO_INVALID_INSTANCE;
         }
         gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
-                1, gpioCallback->callbackArgs);
+                gpio::Levels::HIGH, gpioCallback->callbackArgs);
         return RETURN_OK;
     }
     return GPIO_TYPE_FAILURE;
@@ -196,13 +231,18 @@ ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
 ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
     gpioMapIter = gpioMap.find(gpioId);
     if (gpioMapIter == gpioMap.end()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::pullLow: Unknown GPIO ID " << gpioId << std::endl;
+#else
+        sif::printWarning("LinuxLibgpioIF::pullLow: Unknown GPIO ID %d\n", gpioId);
+#endif
         return UNKNOWN_GPIO_ID;
     }
 
     auto& gpioType = gpioMapIter->second->gpioType;
-    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -215,7 +255,7 @@ ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
             return GPIO_INVALID_INSTANCE;
         }
         gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
-                0, gpioCallback->callbackArgs);
+                gpio::Levels::LOW, gpioCallback->callbackArgs);
         return RETURN_OK;
     }
     return GPIO_TYPE_FAILURE;
@@ -225,8 +265,13 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId,
         GpiodRegularBase& regularGpio, gpio::Levels logicLevel) {
     int result = gpiod_line_set_value(regularGpio.lineHandle, logicLevel);
     if (result < 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID " << gpioId <<
                 " to logic level " << logicLevel << std::endl;
+#else
+        sif::printWarning("LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID %d to "
+                "logic level %d\n", gpioId, logicLevel);
+#endif
         return DRIVE_GPIO_FAILURE;
     }
 
@@ -236,12 +281,18 @@ ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId,
 ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
     gpioMapIter = gpioMap.find(gpioId);
     if (gpioMapIter == gpioMap.end()){
+#if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LinuxLibgpioIF::readGpio: Unknown GPIOD ID " << gpioId << std::endl;
+#else
+        sif::printWarning("LinuxLibgpioIF::readGpio: Unknown GPIOD ID %d\n", gpioId);
+#endif
         return UNKNOWN_GPIO_ID;
     }
+
     auto gpioType = gpioMapIter->second->gpioType;
-    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+    if (gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP
-            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL
+            or gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME) {
         auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
         if(regularGpio == nullptr) {
             return GPIO_TYPE_FAILURE;
@@ -249,10 +300,14 @@ ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
         *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
     }
     else {
-
+        auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
+        if(gpioCallback->callback == nullptr) {
+            return GPIO_INVALID_INSTANCE;
+        }
+        gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::READ,
+                gpio::Levels::NONE, gpioCallback->callbackArgs);
+        return RETURN_OK;
     }
-
-
     return RETURN_OK;
 }
 
@@ -262,13 +317,14 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
     for(auto& gpioConfig: mapToAdd) {
         switch(gpioConfig.second->gpioType) {
         case(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
-        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
             auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioConfig.second);
             if(regularGpio == nullptr)  {
                 return GPIO_TYPE_FAILURE;
             }
-            /* Check for conflicts and remove duplicates if necessary */
+            // Check for conflicts and remove duplicates if necessary
-            result = checkForConflictsRegularGpio(gpioConfig.first, *regularGpio, mapToAdd);
+            result = checkForConflictsById(gpioConfig.first, gpioConfig.second->gpioType, mapToAdd);
             if(result != HasReturnvaluesIF::RETURN_OK) {
                 status = result;
             }
@@ -279,66 +335,108 @@ ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
             if(callbackGpio == nullptr)  {
                 return GPIO_TYPE_FAILURE;
             }
-            /* Check for conflicts and remove duplicates if necessary */
+            // Check for conflicts and remove duplicates if necessary
-            result = checkForConflictsCallbackGpio(gpioConfig.first, callbackGpio, mapToAdd);
+            result = checkForConflictsById(gpioConfig.first,
+                    gpioConfig.second->gpioType, mapToAdd);
             if(result != HasReturnvaluesIF::RETURN_OK) {
                 status = result;
             }
             break;
         }
         default: {
-
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "Invalid GPIO type detected for GPIO ID " << gpioConfig.first
+                    << std::endl;
+#else
+            sif::printWarning("Invalid GPIO type detected for GPIO ID %d\n", gpioConfig.first);
+#endif
+            status = GPIO_TYPE_FAILURE;
         }
         }
     }
     return status;
 }
 
-
+ReturnValue_t LinuxLibgpioIF::checkForConflictsById(gpioId_t gpioIdToCheck,
-ReturnValue_t LinuxLibgpioIF::checkForConflictsRegularGpio(gpioId_t gpioIdToCheck,
+        gpio::GpioTypes expectedType, GpioMap& mapToAdd) {
-        GpiodRegularBase& gpioToCheck, GpioMap& mapToAdd) {
+    // Cross check with private map
-    /* Cross check with private map */
     gpioMapIter = gpioMap.find(gpioIdToCheck);
     if(gpioMapIter != gpioMap.end()) {
         auto& gpioType = gpioMapIter->second->gpioType;
-        if(gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_CHIP and
+        bool eraseDuplicateDifferentType = false;
-                gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+        switch(expectedType) {
-            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+        case(gpio::GpioTypes::NONE): {
-                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
+            break;
-            mapToAdd.erase(gpioIdToCheck);
-            return HasReturnvaluesIF::RETURN_OK;
         }
-        auto ownRegularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
-        if(ownRegularGpio == nullptr) {
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):
-            return GPIO_TYPE_FAILURE;
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LINE_NAME): {
+            if(gpioType == gpio::GpioTypes::NONE or gpioType == gpio::GpioTypes::CALLBACK) {
+                eraseDuplicateDifferentType = true;
+            }
+            break;
+        }
+        case(gpio::GpioTypes::CALLBACK): {
+            if(gpioType != gpio::GpioTypes::CALLBACK) {
+                eraseDuplicateDifferentType = true;
+            }
+        }
+        }
+        if(eraseDuplicateDifferentType) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for "
+                    "different GPIO type " << gpioIdToCheck <<
+                    ". Removing duplicate from map to add" << std::endl;
+#else
+            sif::printWarning("LinuxLibgpioIF::checkForConflicts: ID already exists for "
+                    "different GPIO type %d. Removing duplicate from map to add\n", gpioIdToCheck);
+#endif
+            mapToAdd.erase(gpioIdToCheck);
+            return GPIO_DUPLICATE_DETECTED;
         }
 
-        /* Remove element from map to add because a entry for this GPIO
+        // Remove element from map to add because a entry for this GPIO already exists
-        already exists */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO "
-                << " detected. Duplicate will be removed from map to add." << std::endl;
+                "definition with ID " << gpioIdToCheck << " detected. " <<
+                "Duplicate will be removed from map to add" << std::endl;
+#else
+        sif::printWarning("LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition "
+                "with ID %d detected. Duplicate will be removed from map to add\n", gpioIdToCheck);
+#endif
         mapToAdd.erase(gpioIdToCheck);
+        return GPIO_DUPLICATE_DETECTED;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t LinuxLibgpioIF::checkForConflictsCallbackGpio(gpioId_t gpioIdToCheck,
+void LinuxLibgpioIF::parseFindeLineResult(int result, std::string& lineName) {
-        GpioCallback *callbackGpio, GpioMap& mapToAdd) {
+    switch (result) {
-    /* Cross check with private map */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
-    gpioMapIter = gpioMap.find(gpioIdToCheck);
+    case LINE_NOT_EXISTS:
-    if(gpioMapIter != gpioMap.end()) {
+    case LINE_ERROR: {
-        if(gpioMapIter->second->gpioType != gpio::GpioTypes::CALLBACK) {
+        sif::warning << "LinuxLibgpioIF::parseFindeLineResult: Line with name " << lineName <<
-            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                " does not exist" << std::endl;
-                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
+        break;
-            mapToAdd.erase(gpioIdToCheck);
+    }
-            return HasReturnvaluesIF::RETURN_OK;
+    default: {
+        sif::warning << "LinuxLibgpioIF::parseFindeLineResult: Unknown return code for line "
+                "with name " << lineName << std::endl;
+        break;
+    }
+#else
+    case LINE_NOT_EXISTS:
+    case LINE_ERROR: {
+        sif::printWarning("LinuxLibgpioIF::parseFindeLineResult: Line with name %s "
+                "does not exist\n", lineName);
+        break;
+    }
+    default: {
+        sif::printWarning("LinuxLibgpioIF::parseFindeLineResult: Unknown return code for line "
+                "with name %s\n", lineName);
+        break;
+    }
+#endif
     }
 
-        /* Remove element from map to add because a entry for this GPIO
-        already exists */
-        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
-                << " detected. Duplicate will be removed from map to add." << std::endl;
-        mapToAdd.erase(gpioIdToCheck);
-    }
-    return HasReturnvaluesIF::RETURN_OK;
 }

hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h

@@ -1,19 +1,19 @@
 #ifndef LINUX_GPIO_LINUXLIBGPIOIF_H_
 #define LINUX_GPIO_LINUXLIBGPIOIF_H_
 
-#include "../../common/gpio/GpioIF.h"
+#include "fsfw/returnvalues/FwClassIds.h"
-#include <returnvalues/classIds.h>
+#include "fsfw_hal/common/gpio/GpioIF.h"
-#include <fsfw/objectmanager/SystemObject.h>
+#include "fsfw/objectmanager/SystemObject.h"
 
 class GpioCookie;
 class GpiodRegularIF;
 
 /**
- * @brief	This class implements the GpioIF for a linux based system. The
+ * @brief	This class implements the GpioIF for a linux based system.
- * 			implementation is based on the libgpiod lib which requires linux 4.8
+ * @details
- * 			or higher.
+ * This implementation is based on the libgpiod lib which requires Linux 4.8 or higher.
- * @note	The Petalinux SDK from Xilinx supports libgpiod since Petalinux
+ * @note
- * 			2019.1.
+ * The Petalinux SDK from Xilinx supports libgpiod since Petalinux 2019.1.
  */
 class LinuxLibgpioIF : public GpioIF, public SystemObject {
 public:
@@ -28,6 +28,8 @@ public:
             HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 3);
     static constexpr ReturnValue_t GPIO_INVALID_INSTANCE =
             HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
+    static constexpr ReturnValue_t GPIO_DUPLICATE_DETECTED =
+            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 5);
 
 	LinuxLibgpioIF(object_id_t objectId);
 	virtual ~LinuxLibgpioIF();
@@ -38,7 +40,13 @@ public:
 	ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
 
 private:
-	/* Holds the information and configuration of all used GPIOs */
+
+	static const size_t MAX_CHIPNAME_LENGTH = 11;
+	static const int LINE_NOT_EXISTS = 0;
+	static const int LINE_ERROR = -1;
+	static const int LINE_FOUND = 1;
+
+	// Holds the information and configuration of all used GPIOs
 	GpioUnorderedMap gpioMap;
 	GpioUnorderedMapIter gpioMapIter;
 
@@ -53,8 +61,10 @@ private:
 
 	ReturnValue_t configureGpioByLabel(gpioId_t gpioId, GpiodRegularByLabel& gpioByLabel);
 	ReturnValue_t configureGpioByChip(gpioId_t gpioId, GpiodRegularByChip& gpioByChip);
-    ReturnValue_t configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+    ReturnValue_t configureGpioByLineName(gpioId_t gpioId,
-            struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput);
+            GpiodRegularByLineName &gpioByLineName);
+    ReturnValue_t configureRegularGpio(gpioId_t gpioId, struct gpiod_chip* chip,
+            GpiodRegularBase& regularGpio, std::string failOutput);
 
 	/**
 	 * @brief	This function checks if GPIOs are already registered and whether
@@ -67,9 +77,7 @@ private:
 	 */
 	ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
 
-	ReturnValue_t checkForConflictsRegularGpio(gpioId_t gpiodId, GpiodRegularBase& regularGpio,
+	ReturnValue_t checkForConflictsById(gpioId_t gpiodId, gpio::GpioTypes type,
-	        GpioMap& mapToAdd);
-    ReturnValue_t checkForConflictsCallbackGpio(gpioId_t gpiodId, GpioCallback* regularGpio,
 	        GpioMap& mapToAdd);
 
 	/**
@@ -77,6 +85,7 @@ private:
 	 */
 	ReturnValue_t configureGpios(GpioMap& mapToAdd);
 
+	void parseFindeLineResult(int result, std::string& lineName);
 };
 
 #endif /* LINUX_GPIO_LINUXLIBGPIOIF_H_ */

hal/src/fsfw_hal/stm32h7/definitions.h

@@ -0,0 +1,25 @@
+#ifndef FSFW_HAL_STM32H7_DEFINITIONS_H_
+#define FSFW_HAL_STM32H7_DEFINITIONS_H_
+
+#include <utility>
+#include "stm32h7xx.h"
+
+namespace stm32h7 {
+
+/**
+ * Typedef for STM32 GPIO pair where the first entry is the port used (e.g. GPIOA)
+ * and the second entry is the pin number
+ */
+struct GpioCfg {
+    GpioCfg(): port(nullptr), pin(0), altFnc(0) {};
+
+    GpioCfg(GPIO_TypeDef* port, uint16_t pin, uint8_t altFnc = 0):
+        port(port), pin(pin), altFnc(altFnc) {};
+    GPIO_TypeDef* port;
+    uint16_t pin;
+    uint8_t altFnc;
+};
+
+}
+
+#endif /* #ifndef FSFW_HAL_STM32H7_DEFINITIONS_H_ */

hal/src/fsfw_hal/stm32h7/devicetest/GyroL3GD20H.cpp

@@ -4,7 +4,7 @@
 #include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
 #include "fsfw_hal/stm32h7/spi/spiCore.h"
 #include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
-#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
+#include "fsfw_hal/stm32h7/spi/stm32h743zi.h"
 
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -33,20 +33,20 @@ GyroL3GD20H::GyroL3GD20H(SPI_HandleTypeDef *spiHandle, spi::TransferModes transf
         mspCfg = new spi::MspDmaConfigStruct();
         auto typedCfg = dynamic_cast<spi::MspDmaConfigStruct*>(mspCfg);
         spi::setDmaHandles(txDmaHandle, rxDmaHandle);
-        spi::h743zi::standardDmaCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS,
+        stm32h7::h743zi::standardDmaCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS,
                 IrqPriorities::HIGHEST_FREERTOS, IrqPriorities::HIGHEST_FREERTOS);
         spi::setSpiDmaMspFunctions(typedCfg);
     }
     else if(transferMode == spi::TransferModes::INTERRUPT) {
         mspCfg = new spi::MspIrqConfigStruct();
         auto typedCfg = dynamic_cast<spi::MspIrqConfigStruct*>(mspCfg);
-        spi::h743zi::standardInterruptCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS);
+        stm32h7::h743zi::standardInterruptCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS);
         spi::setSpiIrqMspFunctions(typedCfg);
     }
     else if(transferMode == spi::TransferModes::POLLING) {
         mspCfg = new spi::MspPollingConfigStruct();
         auto typedCfg = dynamic_cast<spi::MspPollingConfigStruct*>(mspCfg);
-        spi::h743zi::standardPollingCfg(*typedCfg);
+        stm32h7::h743zi::standardPollingCfg(*typedCfg);
         spi::setSpiPollingMspFunctions(typedCfg);
     }
 

hal/src/fsfw_hal/stm32h7/spi/CMakeLists.txt

@@ -5,5 +5,5 @@ target_sources(${LIB_FSFW_NAME} PRIVATE
     mspInit.cpp
     SpiCookie.cpp
     SpiComIF.cpp
-    stm32h743ziSpi.cpp
+    stm32h743zi.cpp
 )

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

@@ -138,12 +138,14 @@ ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
         spi::setSpiDmaMspFunctions(typedCfg);
     }
 
+    if(gpioPort != nullptr) {
         gpio::initializeGpioClock(gpioPort);
         GPIO_InitTypeDef chipSelect = {};
         chipSelect.Pin = gpioPin;
         chipSelect.Mode = GPIO_MODE_OUTPUT_PP;
         HAL_GPIO_Init(gpioPort, &chipSelect);
         HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_SET);
+    }
 
     if(HAL_SPI_Init(&spiHandle) != HAL_OK) {
         sif::printWarning("SpiComIF::initialize: Error initializing SPI\n");
@@ -259,10 +261,15 @@ ReturnValue_t SpiComIF::handlePollingSendOperation(uint8_t* recvPtr, SPI_HandleT
         return returnval;
     }
     spiCookie.setTransferState(spi::TransferStates::WAIT);
+    if(gpioPort != nullptr) {
         HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_RESET);
+    }
+
     auto result = HAL_SPI_TransmitReceive(&spiHandle, const_cast<uint8_t*>(sendData),
             recvPtr, sendLen, defaultPollingTimeout);
+    if(gpioPort != nullptr) {
         HAL_GPIO_WritePin(gpioPort, gpioPin,  GPIO_PIN_SET);
+    }
     spiSemaphore->release();
     switch(result) {
     case(HAL_OK): {
@@ -392,8 +399,10 @@ ReturnValue_t SpiComIF::genericIrqSendSetup(uint8_t *recvPtr, SPI_HandleTypeDef&
     // The SPI handle is passed to the default SPI callback as a void argument. This callback
     // is different from the user callbacks specified above!
     spi::assignSpiUserArgs(spiCookie.getSpiIdx(), reinterpret_cast<void*>(&spiHandle));
+    if(spiCookie.getChipSelectGpioPort() != nullptr) {
         HAL_GPIO_WritePin(spiCookie.getChipSelectGpioPort(), spiCookie.getChipSelectGpioPin(),
                 GPIO_PIN_RESET);
+    }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -426,9 +435,12 @@ void SpiComIF::genericIrqHandler(void *irqArgsVoid, spi::TransferStates targetSt
 
     spiCookie->setTransferState(targetState);
 
+    if(spiCookie->getChipSelectGpioPort() != nullptr) {
         // Pull CS pin high again
         HAL_GPIO_WritePin(spiCookie->getChipSelectGpioPort(), spiCookie->getChipSelectGpioPin(),
                 GPIO_PIN_SET);
+    }
+
 
 #if defined FSFW_OSAL_FREERTOS
     // Release the task semaphore

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

@@ -60,7 +60,6 @@ public:
     void addDmaHandles(DMA_HandleTypeDef* txHandle, DMA_HandleTypeDef* rxHandle);
 
     ReturnValue_t initialize() override;
-protected:
 
     // DeviceCommunicationIF overrides
     virtual ReturnValue_t initializeInterface(CookieIF * cookie) override;
@@ -72,7 +71,7 @@ protected:
     virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
             uint8_t **buffer, size_t *size) override;
 
-private:
+protected:
 
     struct SpiInstance {
         SpiInstance(size_t maxRecvSize): replyBuffer(std::vector<uint8_t>(maxRecvSize)) {}

hal/src/fsfw_hal/stm32h7/spi/SpiCookie.cpp

@@ -3,10 +3,10 @@
 
 SpiCookie::SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferModes transferMode,
         spi::MspCfgBase* mspCfg, uint32_t spiSpeed, spi::SpiModes spiMode,
-        uint16_t chipSelectGpioPin, GPIO_TypeDef* chipSelectGpioPort, size_t maxRecvSize):
+        size_t maxRecvSize, stm32h7::GpioCfg csGpio):
         deviceAddress(deviceAddress), spiIdx(spiIdx), spiSpeed(spiSpeed), spiMode(spiMode),
-        transferMode(transferMode), chipSelectGpioPin(chipSelectGpioPin),
+        transferMode(transferMode), csGpio(csGpio),
-        chipSelectGpioPort(chipSelectGpioPort), mspCfg(mspCfg), maxRecvSize(maxRecvSize) {
+        mspCfg(mspCfg), maxRecvSize(maxRecvSize) {
     spiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
     spiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
     spiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
@@ -24,11 +24,11 @@ SpiCookie::SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferM
 }
 
 uint16_t SpiCookie::getChipSelectGpioPin() const {
-    return chipSelectGpioPin;
+    return csGpio.pin;
 }
 
 GPIO_TypeDef* SpiCookie::getChipSelectGpioPort() {
-    return chipSelectGpioPort;
+    return csGpio.port;
 }
 
 address_t SpiCookie::getDeviceAddress() const {

hal/src/fsfw_hal/stm32h7/spi/SpiCookie.h

@@ -3,11 +3,14 @@
 
 #include "spiDefinitions.h"
 #include "mspInit.h"
+#include "../definitions.h"
 
 #include "fsfw/devicehandlers/CookieIF.h"
 
 #include "stm32h743xx.h"
 
+#include <utility>
+
 /**
  * @brief   SPI cookie implementation for the STM32H7 device family
  * @details
@@ -18,6 +21,7 @@
 class SpiCookie: public CookieIF {
     friend class SpiComIF;
 public:
+
     /**
      * Allows construction of a SPI cookie for a connected SPI device
      * @param deviceAddress
@@ -32,10 +36,11 @@ public:
      *                              definitions supplied in the MCU header file! (e.g. GPIO_PIN_X)
      * @param chipSelectGpioPort    GPIO port (e.g. GPIOA)
      * @param maxRecvSize           Maximum expected receive size. Chose as small as possible.
+     * @param csGpio                Optional CS GPIO definition.
      */
     SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferModes transferMode,
             spi::MspCfgBase* mspCfg, uint32_t spiSpeed, spi::SpiModes spiMode,
-            uint16_t chipSelectGpioPin, GPIO_TypeDef* chipSelectGpioPort, size_t maxRecvSize);
+            size_t maxRecvSize, stm32h7::GpioCfg csGpio = stm32h7::GpioCfg(nullptr, 0, 0));
 
     uint16_t getChipSelectGpioPin() const;
     GPIO_TypeDef* getChipSelectGpioPort();
@@ -55,8 +60,8 @@ private:
     spi::SpiModes spiMode;
     spi::TransferModes transferMode;
     volatile spi::TransferStates transferState = spi::TransferStates::IDLE;
-    uint16_t chipSelectGpioPin;
+    stm32h7::GpioCfg csGpio;
-    GPIO_TypeDef* chipSelectGpioPort;
+
     // The MSP configuration is cached here. Be careful when using this, it is automatically
     // deleted by the SPI  communication interface if it is not required anymore!
     spi::MspCfgBase* mspCfg = nullptr;

hal/src/fsfw_hal/stm32h7/spi/mspInit.cpp

@@ -118,40 +118,40 @@ void spi::halMspInitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
     GPIO_InitTypeDef GPIO_InitStruct = {};
     /*##-1- Enable peripherals and GPIO Clocks #################################*/
     /* Enable GPIO TX/RX clock */
-    cfg->setupMacroWrapper();
+    cfg->setupCb();
 
     /*##-2- Configure peripheral GPIO ##########################################*/
     /* SPI SCK GPIO pin configuration  */
-    GPIO_InitStruct.Pin       = cfg->sckPin;
+    GPIO_InitStruct.Pin       = cfg->sck.pin;
     GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
     GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
-    GPIO_InitStruct.Alternate = cfg->sckAlternateFunction;
+    GPIO_InitStruct.Alternate = cfg->sck.altFnc;
-    HAL_GPIO_Init(cfg->sckPort, &GPIO_InitStruct);
+    HAL_GPIO_Init(cfg->sck.port, &GPIO_InitStruct);
 
     /* SPI MISO GPIO pin configuration  */
-    GPIO_InitStruct.Pin = cfg->misoPin;
+    GPIO_InitStruct.Pin = cfg->miso.pin;
-    GPIO_InitStruct.Alternate = cfg->misoAlternateFunction;
+    GPIO_InitStruct.Alternate = cfg->miso.altFnc;
-    HAL_GPIO_Init(cfg->misoPort, &GPIO_InitStruct);
+    HAL_GPIO_Init(cfg->miso.port, &GPIO_InitStruct);
 
     /* SPI MOSI GPIO pin configuration  */
-    GPIO_InitStruct.Pin = cfg->mosiPin;
+    GPIO_InitStruct.Pin = cfg->mosi.pin;
-    GPIO_InitStruct.Alternate = cfg->mosiAlternateFunction;
+    GPIO_InitStruct.Alternate = cfg->mosi.altFnc;
-    HAL_GPIO_Init(cfg->mosiPort, &GPIO_InitStruct);
+    HAL_GPIO_Init(cfg->mosi.port, &GPIO_InitStruct);
 }
 
 void spi::halMspDeinitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
     auto cfg = reinterpret_cast<MspPollingConfigStruct*>(cfgBase);
     // Reset peripherals
-    cfg->cleanUpMacroWrapper();
+    cfg->cleanupCb();
 
     // Disable peripherals and GPIO Clocks
     /* Configure SPI SCK as alternate function  */
-    HAL_GPIO_DeInit(cfg->sckPort, cfg->sckPin);
+    HAL_GPIO_DeInit(cfg->sck.port, cfg->sck.pin);
     /* Configure SPI MISO as alternate function  */
-    HAL_GPIO_DeInit(cfg->misoPort, cfg->misoPin);
+    HAL_GPIO_DeInit(cfg->miso.port, cfg->miso.pin);
     /* Configure SPI MOSI as alternate function  */
-    HAL_GPIO_DeInit(cfg->mosiPort, cfg->mosiPin);
+    HAL_GPIO_DeInit(cfg->mosi.port, cfg->mosi.pin);
 }
 
 void spi::halMspInitInterrupt(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {

hal/src/fsfw_hal/stm32h7/spi/mspInit.h

@@ -2,6 +2,7 @@
 #define FSFW_HAL_STM32H7_SPI_MSPINIT_H_
 
 #include "spiDefinitions.h"
+#include "../definitions.h"
 #include "../dma.h"
 
 #include "stm32h7xx_hal_spi.h"
@@ -12,6 +13,8 @@
 extern "C" {
 #endif
 
+using mspCb = void (*) (void);
+
 /**
  * @brief   This file provides MSP implementation for DMA, IRQ and Polling mode for the
  *          SPI peripheral. This configuration is required for the SPI communication to work.
@@ -19,27 +22,37 @@ extern "C" {
 namespace spi {
 
 struct MspCfgBase {
+    MspCfgBase();
+    MspCfgBase(stm32h7::GpioCfg sck, stm32h7::GpioCfg mosi, stm32h7::GpioCfg miso,
+            mspCb cleanupCb = nullptr, mspCb setupCb = nullptr):
+        sck(sck), mosi(mosi), miso(miso), cleanupCb(cleanupCb),
+        setupCb(setupCb) {}
+
     virtual ~MspCfgBase() = default;
 
-    void (* cleanUpMacroWrapper) (void) = nullptr;
+    stm32h7::GpioCfg sck;
-    void (* setupMacroWrapper) (void) = nullptr;
+    stm32h7::GpioCfg mosi;
+    stm32h7::GpioCfg miso;
 
-   GPIO_TypeDef* sckPort = nullptr;
+    mspCb cleanupCb = nullptr;
-   uint32_t sckPin = 0;
+    mspCb setupCb = nullptr;
-   uint8_t sckAlternateFunction = 0;
-   GPIO_TypeDef* mosiPort = nullptr;
-   uint32_t mosiPin = 0;
-   uint8_t mosiAlternateFunction = 0;
-   GPIO_TypeDef* misoPort = nullptr;
-   uint32_t misoPin = 0;
-   uint8_t misoAlternateFunction = 0;
 };
 
-struct MspPollingConfigStruct: public MspCfgBase {};
+struct MspPollingConfigStruct: public MspCfgBase {
+    MspPollingConfigStruct(): MspCfgBase() {};
+    MspPollingConfigStruct(stm32h7::GpioCfg sck, stm32h7::GpioCfg mosi, stm32h7::GpioCfg miso,
+            mspCb cleanupCb = nullptr, mspCb setupCb = nullptr):
+            MspCfgBase(sck, mosi, miso, cleanupCb, setupCb) {}
+};
 
 /* A valid instance of this struct must be passed to the MSP initialization function as a void*
 argument */
 struct MspIrqConfigStruct: public MspPollingConfigStruct {
+    MspIrqConfigStruct(): MspPollingConfigStruct() {};
+    MspIrqConfigStruct(stm32h7::GpioCfg sck, stm32h7::GpioCfg mosi, stm32h7::GpioCfg miso,
+            mspCb cleanupCb = nullptr, mspCb setupCb = nullptr):
+            MspPollingConfigStruct(sck, mosi, miso, cleanupCb, setupCb) {}
+
     SpiBus spiBus = SpiBus::SPI_1;
     user_handler_t spiIrqHandler = nullptr;
     user_args_t spiUserArgs = nullptr;
@@ -53,11 +66,16 @@ struct MspIrqConfigStruct: public MspPollingConfigStruct {
 /* A valid instance of this struct must be passed to the MSP initialization function as a void*
 argument */
 struct MspDmaConfigStruct: public MspIrqConfigStruct {
+    MspDmaConfigStruct(): MspIrqConfigStruct() {};
+    MspDmaConfigStruct(stm32h7::GpioCfg sck, stm32h7::GpioCfg mosi, stm32h7::GpioCfg miso,
+            mspCb cleanupCb = nullptr, mspCb setupCb = nullptr):
+            MspIrqConfigStruct(sck, mosi, miso, cleanupCb, setupCb) {}
     void (* dmaClkEnableWrapper) (void) = nullptr;
-    dma::DMAIndexes txDmaIndex;
+
-    dma::DMAIndexes rxDmaIndex;
+    dma::DMAIndexes txDmaIndex = dma::DMAIndexes::DMA_1;
-    dma::DMAStreams txDmaStream;
+    dma::DMAIndexes rxDmaIndex = dma::DMAIndexes::DMA_1;
-    dma::DMAStreams rxDmaStream;
+    dma::DMAStreams txDmaStream = dma::DMAStreams::STREAM_0;
+    dma::DMAStreams rxDmaStream = dma::DMAStreams::STREAM_0;
     IRQn_Type txDmaIrqNumber = DMA1_Stream0_IRQn;
     IRQn_Type rxDmaIrqNumber = DMA1_Stream1_IRQn;
     // Priorities for NVIC

hal/src/fsfw_hal/stm32h7/spi/stm32h743zi.cpp

@@ -1,4 +1,4 @@
-#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
+#include "fsfw_hal/stm32h7/spi/stm32h743zi.h"
 #include "fsfw_hal/stm32h7/spi/spiCore.h"
 #include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
 
@@ -22,27 +22,27 @@ void spiDmaClockEnableWrapper() {
     __HAL_RCC_DMA2_CLK_ENABLE();
 }
 
-void spi::h743zi::standardPollingCfg(MspPollingConfigStruct& cfg) {
+void stm32h7::h743zi::standardPollingCfg(spi::MspPollingConfigStruct& cfg) {
-    cfg.setupMacroWrapper =  &spiSetupWrapper;
+    cfg.setupCb =  &spiSetupWrapper;
-    cfg.cleanUpMacroWrapper = &spiCleanUpWrapper;
+    cfg.cleanupCb = &spiCleanUpWrapper;
-    cfg.sckPort = GPIOA;
+    cfg.sck.port = GPIOA;
-    cfg.sckPin = GPIO_PIN_5;
+    cfg.sck.pin = GPIO_PIN_5;
-    cfg.misoPort = GPIOA;
+    cfg.miso.port = GPIOA;
-    cfg.misoPin = GPIO_PIN_6;
+    cfg.miso.pin = GPIO_PIN_6;
-    cfg.mosiPort = GPIOA;
+    cfg.mosi.port = GPIOA;
-    cfg.mosiPin = GPIO_PIN_7;
+    cfg.mosi.pin = GPIO_PIN_7;
-    cfg.sckAlternateFunction = GPIO_AF5_SPI1;
+    cfg.sck.altFnc = GPIO_AF5_SPI1;
-    cfg.mosiAlternateFunction = GPIO_AF5_SPI1;
+    cfg.mosi.altFnc = GPIO_AF5_SPI1;
-    cfg.misoAlternateFunction = GPIO_AF5_SPI1;
+    cfg.miso.altFnc = GPIO_AF5_SPI1;
 }
 
-void spi::h743zi::standardInterruptCfg(MspIrqConfigStruct& cfg, IrqPriorities spiIrqPrio,
+void stm32h7::h743zi::standardInterruptCfg(spi::MspIrqConfigStruct& cfg, IrqPriorities spiIrqPrio,
         IrqPriorities spiSubprio) {
     // High, but works on FreeRTOS as well (priorities range from 0 to 15)
     cfg.preEmptPriority = spiIrqPrio;
     cfg.subpriority = spiSubprio;
     cfg.spiIrqNumber = SPI1_IRQn;
-    cfg.spiBus = SpiBus::SPI_1;
+    cfg.spiBus = spi::SpiBus::SPI_1;
     user_handler_t spiUserHandler = nullptr;
     user_args_t spiUserArgs = nullptr;
     getSpiUserHandler(spi::SpiBus::SPI_1, &spiUserHandler, &spiUserArgs);
@@ -55,7 +55,7 @@ void spi::h743zi::standardInterruptCfg(MspIrqConfigStruct& cfg, IrqPriorities sp
     standardPollingCfg(cfg);
 }
 
-void spi::h743zi::standardDmaCfg(MspDmaConfigStruct& cfg, IrqPriorities spiIrqPrio,
+void stm32h7::h743zi::standardDmaCfg(spi::MspDmaConfigStruct& cfg, IrqPriorities spiIrqPrio,
         IrqPriorities txIrqPrio, IrqPriorities rxIrqPrio, IrqPriorities spiSubprio,
         IrqPriorities txSubprio, IrqPriorities rxSubprio) {
     cfg.dmaClkEnableWrapper = &spiDmaClockEnableWrapper;

hal/src/fsfw_hal/stm32h7/spi/stm32h743zi.h

@@ -3,21 +3,20 @@
 
 #include "mspInit.h"
 
-namespace spi {
+namespace stm32h7 {
 
 namespace h743zi {
 
-void standardPollingCfg(MspPollingConfigStruct& cfg);
+void standardPollingCfg(spi::MspPollingConfigStruct& cfg);
-void standardInterruptCfg(MspIrqConfigStruct& cfg, IrqPriorities spiIrqPrio,
+void standardInterruptCfg(spi::MspIrqConfigStruct& cfg, IrqPriorities spiIrqPrio,
         IrqPriorities spiSubprio = HIGHEST);
-void standardDmaCfg(MspDmaConfigStruct& cfg, IrqPriorities spiIrqPrio,
+void standardDmaCfg(spi::MspDmaConfigStruct& cfg, IrqPriorities spiIrqPrio,
         IrqPriorities txIrqPrio, IrqPriorities rxIrqPrio,
         IrqPriorities spiSubprio = HIGHEST, IrqPriorities txSubPrio = HIGHEST,
         IrqPriorities rxSubprio = HIGHEST);
 
+
 }
 }
 
-
-
 #endif /* FSFW_HAL_STM32H7_SPI_STM32H743ZISPI_H_ */

misc/defaultcfg/fsfwconfig/CMakeLists.txt

@@ -1,23 +1,49 @@
-target_include_directories(${TARGET_NAME} PRIVATE
+if(DEFINED TARGET_NAME) 
+    target_include_directories(${TARGET_NAME} PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}
-)
+    )
 
-target_sources(${TARGET_NAME} PRIVATE
+    target_sources(${TARGET_NAME} PRIVATE
         ipc/missionMessageTypes.cpp
         pollingsequence/PollingSequenceFactory.cpp
         objects/FsfwFactory.cpp
-)
+    )
 
-# If a special translation file for object IDs exists, compile it.
+    # If a special translation file for object IDs exists, compile it.
-if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
         target_sources(${TARGET_NAME} PRIVATE
             objects/translateObjects.cpp
         )
-endif()
+    endif()
 
-# If a special translation file for events exists, compile it.
+    # If a special translation file for events exists, compile it.
-if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
         target_sources(${TARGET_NAME} PRIVATE
             events/translateEvents.cpp
         )
+    endif()
+else()
+    target_include_directories(${LIB_FSFW_NAME} PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
+    target_sources(${LIB_FSFW_NAME} PRIVATE
+        ipc/missionMessageTypes.cpp
+        pollingsequence/PollingSequenceFactory.cpp
+        objects/FsfwFactory.cpp
+    )
+
+    # If a special translation file for object IDs exists, compile it.
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+        target_sources(${LIB_FSFW_NAME} PRIVATE
+            objects/translateObjects.cpp
+        )
+    endif()
+
+    # If a special translation file for events exists, compile it.
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+        target_sources(${LIB_FSFW_NAME} PRIVATE
+            events/translateEvents.cpp
+        )
+    endif()
 endif()

misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp

@@ -7,7 +7,7 @@
 #include <fsfw/tmtcpacket/pus/tm/TmPacketStored.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/internalError/InternalErrorReporter.h>
+#include <fsfw/internalerror/InternalErrorReporter.h>
 
 #include <cstdint>
 
@@ -48,6 +48,6 @@ void Factory::setStaticFrameworkObjectIds() {
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-	TmPacketStored::timeStamperId = objects::NO_OBJECT;
+	TmPacketBase::timeStamperId = objects::NO_OBJECT;
 }
 

scripts/apply-clang-format.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+if [[ ! -f README.md ]]; then
+	cd ..
+fi
+
+find ./src -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./hal -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./tests -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i

scripts/helper.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*
+"""Small portable helper script to generate test or doc configuration for the
+flight software framework
+"""
+import os
+import argparse
+import webbrowser
+import shutil
+import sys
+import time
+from typing import List
+
+
+UNITTEST_FOLDER_NAME = 'build-tests'
+DOCS_FOLDER_NAME = 'build-docs'
+
+
+def main():
+
+    parser = argparse.ArgumentParser(description="FSFW helper script")
+    choices = ('docs', 'tests')
+    parser.add_argument(
+        'type', metavar='type', choices=choices,
+        help=f'Target type. Choices: {choices}'
+    )
+    parser.add_argument(
+        '-a', '--all', action='store_true',
+        help='Create, build and open specified type'
+    )
+    parser.add_argument(
+        '-c', '--create', action='store_true',
+        help='Create docs or test build configuration'
+    )
+    parser.add_argument(
+        '-b', '--build', action='store_true',
+        help='Build the specified type'
+    )
+    parser.add_argument(
+        '-o', '--open', action='store_true',
+        help='Open test or documentation data in webbrowser'
+    )
+
+    args = parser.parse_args()
+    if args.all:
+        args.build = True
+        args.create = True
+        args.open = True
+    elif not args.build and not args.create and not args.open:
+        print(
+            'Please select at least one operation to perform. '
+            'Use helper.py -h for more information'
+        )
+        sys.exit(1)
+
+    # This script can be called from root and from script folder
+    if not os.path.isfile('README.md'):
+        os.chdir('..')
+    build_dir_list = []
+    if not args.create:
+        build_dir_list = build_build_dir_list()
+
+    if args.type == 'tests':
+        handle_tests_type(args, build_dir_list)
+    elif args.type == 'docs':
+        handle_docs_type(args, build_dir_list)
+    else:
+        print('Invalid or unknown type')
+        sys.exit(1)
+
+
+def handle_docs_type(args, build_dir_list: list):
+    if args.create:
+        if os.path.exists(DOCS_FOLDER_NAME):
+            shutil.rmtree(DOCS_FOLDER_NAME)
+        create_docs_build_cfg()
+        build_directory = DOCS_FOLDER_NAME
+    elif len(build_dir_list) == 0:
+        print('No valid CMake docs build directory found. Trying to set up docs build system')
+        shutil.rmtree(DOCS_FOLDER_NAME)
+        create_docs_build_cfg()
+        build_directory = DOCS_FOLDER_NAME
+    elif len(build_dir_list) == 1:
+        build_directory = build_dir_list[0]
+    else:
+        print("Multiple build directories found!")
+        build_directory = determine_build_dir(build_dir_list)
+    os.chdir(build_directory)
+    if args.build:
+        os.system('cmake --build . -j')
+    if args.open:
+        if not os.path.isfile('docs/sphinx/index.html'):
+            # try again..
+            os.system('cmake --build . -j')
+            if not os.path.isfile('docs/sphinx/index.html'):
+                print(
+                    "No Sphinx documentation file detected. "
+                    "Try to build it first with the -b argument"
+                )
+                sys.exit(1)
+        webbrowser.open('docs/sphinx/index.html')
+
+
+def handle_tests_type(args, build_dir_list: list):
+    if args.create:
+        if os.path.exists(UNITTEST_FOLDER_NAME):
+            shutil.rmtree(UNITTEST_FOLDER_NAME)
+        create_tests_build_cfg()
+        build_directory = UNITTEST_FOLDER_NAME
+    elif len(build_dir_list) == 0:
+        print(
+            'No valid CMake tests build directory found. '
+            'Trying to set up test build system'
+        )
+        create_tests_build_cfg()
+        build_directory = UNITTEST_FOLDER_NAME
+    elif len(build_dir_list) == 1:
+        build_directory = build_dir_list[0]
+    else:
+        print("Multiple build directories found!")
+        build_directory = determine_build_dir(build_dir_list)
+    os.chdir(build_directory)
+    if args.build:
+        perform_lcov_operation(build_directory, False)
+    if args.open:
+        if not os.path.isdir('fsfw-tests_coverage'):
+            print("No Unittest folder detected. Try to build them first with the -b argument")
+            sys.exit(1)
+        webbrowser.open('fsfw-tests_coverage/index.html')
+
+
+def create_tests_build_cfg():
+    os.mkdir(UNITTEST_FOLDER_NAME)
+    os.chdir(UNITTEST_FOLDER_NAME)
+    os.system('cmake -DFSFW_OSAL=host -DFSFW_BUILD_UNITTESTS=ON ..')
+    os.chdir('..')
+
+
+def create_docs_build_cfg():
+    os.mkdir(DOCS_FOLDER_NAME)
+    os.chdir(DOCS_FOLDER_NAME)
+    os.system('cmake -DFSFW_OSAL=host -DFSFW_BUILD_DOCS=ON ..')
+    os.chdir('..')
+
+
+def build_build_dir_list() -> list:
+    build_dir_list = []
+    for directory in os.listdir("."):
+        if os.path.isdir(directory):
+            os.chdir(directory)
+            build_dir_list = check_for_cmake_build_dir(build_dir_list)
+            os.chdir("..")
+    return build_dir_list
+
+
+def check_for_cmake_build_dir(build_dir_list: list) -> list:
+    if os.path.isfile("CMakeCache.txt"):
+        build_dir_list.append(os.getcwd())
+    return build_dir_list
+
+
+def perform_lcov_operation(directory: str, chdir: bool):
+    if chdir:
+        os.chdir(directory)
+    os.system("cmake --build . -- fsfw-tests_coverage -j")
+
+
+def determine_build_dir(build_dir_list: List[str]):
+    build_directory = ""
+    for idx, directory in enumerate(build_dir_list):
+        print(f"{idx + 1}: {directory}")
+    while True:
+        idx = input("Pick the directory: ")
+        if not idx.isdigit():
+            print("Invalid input!")
+            continue
+
+        idx = int(idx)
+        if idx > len(build_dir_list) or idx < 1:
+            print("Invalid input!")
+            continue
+        build_directory = build_dir_list[idx - 1]
+        break
+    return build_directory
+
+
+if __name__ == "__main__":
+    main()

src/CMakeLists.txt

@@ -16,5 +16,3 @@ target_include_directories(${LIB_FSFW_NAME} PRIVATE
 target_include_directories(${LIB_FSFW_NAME} INTERFACE
     ${CMAKE_CURRENT_BINARY_DIR}
 )
-
-configure_file(fsfw/FSFW.h.in fsfw/FSFW.h)

src/fsfw/FSFW.h.in

@@ -16,6 +16,34 @@
 #cmakedefine FSFW_ADD_MONITORING
 #cmakedefine FSFW_ADD_SGP4_PROPAGATOR
 
+// FSFW core defines
+
+#ifndef FSFW_CPP_OSTREAM_ENABLED
+#define FSFW_CPP_OSTREAM_ENABLED            1
+#endif /* FSFW_CPP_OSTREAM_ENABLED */
+
+#ifndef FSFW_VERBOSE_LEVEL
+#define FSFW_VERBOSE_LEVEL                  1
+#endif /* FSFW_VERBOSE_LEVEL */
+
+#ifndef FSFW_USE_REALTIME_FOR_LINUX
+#define FSFW_USE_REALTIME_FOR_LINUX         0
+#endif /* FSFW_USE_REALTIME_FOR_LINUX */
+
+#ifndef FSFW_NO_C99_IO
+#define FSFW_NO_C99_IO                      0
+#endif /* FSFW_NO_C99_IO */
+
+#ifndef FSFW_USE_PUS_C_TELEMETRY
+#define FSFW_USE_PUS_C_TELEMETRY            1
+#endif /* FSFW_USE_PUS_C_TELEMETRY */
+
+#ifndef FSFW_USE_PUS_C_TELECOMMANDS
+#define FSFW_USE_PUS_C_TELECOMMANDS         1
+#endif
+
+// FSFW HAL defines
+
 // Can be used for low-level debugging of the SPI bus
 #ifndef FSFW_HAL_SPI_WIRETAPPING
 #define FSFW_HAL_SPI_WIRETAPPING            0

src/fsfw/FSFWVersion.h

@@ -1,10 +0,0 @@
-#ifndef FSFW_VERSION_H_
-#define FSFW_VERSION_H_
-
-const char* const FSFW_VERSION_NAME = "ASTP";
-
-#define FSFW_VERSION        2
-#define FSFW_SUBVERSION     0
-#define FSFW_REVISION       0
-
-#endif /* FSFW_VERSION_H_ */

src/fsfw/FSFWVersion.h.in

@@ -0,0 +1,9 @@
+#ifndef FSFW_VERSION_H_
+#define FSFW_VERSION_H_
+
+// Versioning is kept in project CMakeLists.txt file
+#define FSFW_VERSION @FSFW_VERSION@
+#define FSFW_SUBVERSION @FSFW_SUBVERSION@
+#define FSFW_REVISION @FSFW_REVISION@
+
+#endif /* FSFW_VERSION_H_ */

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -110,7 +110,7 @@ ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(uint8_t **buffer
     for (uint16_t count = 0; count < fillCount; count++) {
         if(registeredVariables[count]->isValid()) {
             /* Set bit at correct position */
-            bitutil::bitSet(validityPtr + validBufferIndex, validBufferIndexBit);
+            bitutil::set(validityPtr + validBufferIndex, validBufferIndexBit);
         }
         if(validBufferIndexBit == 7) {
             validBufferIndex ++;
@@ -156,8 +156,8 @@ ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
     uint8_t validBufferIndexBit = 0;
     for (uint16_t count = 0; count < fillCount; count++) {
         // set validity buffer here.
-        bool nextVarValid = bitutil::bitGet(*buffer +
+        bool nextVarValid = false;
-                validBufferIndex, validBufferIndexBit);
+        bitutil::get(*buffer + validBufferIndex, validBufferIndexBit, nextVarValid);
         registeredVariables[count]->setValid(nextVarValid);
 
         if(validBufferIndexBit == 7) {

src/fsfw/globalfunctions/PeriodicOperationDivider.cpp

@@ -3,18 +3,17 @@
 
 PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider,
         bool resetAutomatically): resetAutomatically(resetAutomatically),
-		counter(divider), divider(divider) {
+        divider(divider) {
 }
 
 bool PeriodicOperationDivider::checkAndIncrement() {
     bool opNecessary = check();
-	if(opNecessary) {
+    if(opNecessary and resetAutomatically) {
-		if(resetAutomatically) {
+        resetCounter();
-			counter = 0;
     }
-		return opNecessary;
+    else {
+        counter++;
     }
-	counter ++;
     return opNecessary;
 }
 
@@ -25,10 +24,8 @@ bool PeriodicOperationDivider::check() {
     return false;
 }
 
-
-
 void PeriodicOperationDivider::resetCounter() {
-	counter = 0;
+    counter = 1;
 }
 
 void PeriodicOperationDivider::setDivider(uint32_t newDivider) {

src/fsfw/globalfunctions/PeriodicOperationDivider.h

@@ -16,16 +16,15 @@ public:
     /**
      * Initialize with the desired divider and specify whether the internal
      * counter will be reset automatically.
-	 * @param divider
+     * @param divider Value of 0 or 1 will cause #check and #checkAndIncrement to always return
+     * true
      * @param resetAutomatically
      */
     PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true);
 
-
     /**
-	 * Check whether operation is necessary.
+     * Check whether operation is necessary. If an operation is necessary and the class has been
-	 * If an operation is necessary and the class has been
+     * configured to be reset automatically, the counter will be reset to 1 automatically
-	 * configured to be reset automatically, the counter will be reset.
      *
      * @return
      * -@c true if the counter is larger or equal to the divider
@@ -34,8 +33,7 @@ public:
     bool checkAndIncrement();
 
     /**
-	 * Checks whether an operation is necessary.
+     * Checks whether an operation is necessary. This function will not increment the counter.
-	 * This function will not increment the counter!
      * @return
      * -@c true if the counter is larger or equal to the divider
      * -@c false otherwise
@@ -43,7 +41,7 @@ public:
     bool check();
 
     /**
-	 * Can be used to reset the counter to 0 manually.
+     * Can be used to reset the counter to 1 manually
      */
     void resetCounter();
     uint32_t getCounter() const;
@@ -54,9 +52,10 @@ public:
      */
     void setDivider(uint32_t newDivider);
     uint32_t getDivider() const;
+
 private:
     bool resetAutomatically = true;
-	uint32_t counter = 0;
+    uint32_t counter = 1;
     uint32_t divider = 0;
 };
 

src/fsfw/globalfunctions/arrayprinter.cpp

@@ -45,18 +45,18 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
         std::cout << "\r" << std::endl;
     }
 
-    std::cout << "[" << std::hex;
+    std::cout << "hex [" << std::setfill('0') << std::hex;
     for(size_t i = 0; i < size; i++) {
-        std::cout << "0x" << static_cast<int>(data[i]);
+        std::cout <<  std::setw(2) << static_cast<int>(data[i]);
         if(i < size - 1) {
-            std::cout << " , ";
+            std::cout << ",";
             if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 std::cout << std::endl;
 
             }
         }
     }
-    std::cout << std::dec;
+    std::cout << std::dec << std::setfill(' ');
     std::cout << "]" << std::endl;
 #else
     // General format: 0x01, 0x02, 0x03 so it is number of chars times 6
@@ -69,16 +69,16 @@ void arrayprinter::printHex(const uint8_t *data, size_t size,
             break;
         }
 
-        currentPos += snprintf(printBuffer + currentPos, 6, "0x%02x", data[i]);
+        currentPos += snprintf(printBuffer + currentPos, 6, "%02x", data[i]);
         if(i < size - 1) {
-            currentPos += sprintf(printBuffer + currentPos, ", ");
+            currentPos += sprintf(printBuffer + currentPos, ",");
             if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 currentPos += sprintf(printBuffer + currentPos, "\n");
             }
         }
     }
 #if FSFW_DISABLE_PRINTOUT == 0
-    printf("[%s]\n", printBuffer);
+    printf("hex [%s]\n", printBuffer);
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }
@@ -90,11 +90,11 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
         std::cout << "\r" << std::endl;
     }
 
-    std::cout << "[" << std::dec;
+    std::cout << "dec [" << std::dec;
     for(size_t i = 0; i < size; i++) {
         std::cout << static_cast<int>(data[i]);
         if(i < size - 1){
-            std::cout << " , ";
+            std::cout << ",";
             if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 std::cout << std::endl;
             }
@@ -114,14 +114,14 @@ void arrayprinter::printDec(const uint8_t *data, size_t size,
 
         currentPos += snprintf(printBuffer + currentPos, 3, "%d", data[i]);
         if(i < size - 1) {
-            currentPos += sprintf(printBuffer + currentPos, ", ");
+            currentPos += sprintf(printBuffer + currentPos, ",");
             if(i > 0 and (i + 1) % maxCharPerLine == 0) {
                 currentPos += sprintf(printBuffer + currentPos, "\n");
             }
         }
     }
 #if FSFW_DISABLE_PRINTOUT == 0
-    printf("[%s]\n", printBuffer);
+    printf("dec [%s]\n", printBuffer);
 #endif /* FSFW_DISABLE_PRINTOUT == 0 */
 #endif
 }

src/fsfw/globalfunctions/bitutility.cpp

@@ -1,6 +1,6 @@
 #include "fsfw/globalfunctions/bitutility.h"
 
-void bitutil::bitSet(uint8_t *byte, uint8_t position) {
+void bitutil::set(uint8_t *byte, uint8_t position) {
     if(position > 7) {
         return;
     }
@@ -8,7 +8,7 @@ void bitutil::bitSet(uint8_t *byte, uint8_t position) {
     *byte |= 1 << shiftNumber;
 }
 
-void bitutil::bitToggle(uint8_t *byte, uint8_t position) {
+void bitutil::toggle(uint8_t *byte, uint8_t position) {
     if(position > 7) {
         return;
     }
@@ -16,7 +16,7 @@ void bitutil::bitToggle(uint8_t *byte, uint8_t position) {
     *byte ^= 1 << shiftNumber;
 }
 
-void bitutil::bitClear(uint8_t *byte, uint8_t position) {
+void bitutil::clear(uint8_t *byte, uint8_t position) {
     if(position > 7) {
         return;
     }
@@ -24,10 +24,11 @@ void bitutil::bitClear(uint8_t *byte, uint8_t position) {
     *byte &= ~(1 << shiftNumber);
 }
 
-bool bitutil::bitGet(const uint8_t *byte, uint8_t position) {
+bool bitutil::get(const uint8_t *byte, uint8_t position, bool& bit) {
     if(position > 7) {
         return false;
     }
     uint8_t shiftNumber = position + (7 - 2 * position);
-    return *byte & (1 << shiftNumber);
+    bit = *byte & (1 << shiftNumber);
+    return true;
 }

src/fsfw/globalfunctions/bitutility.h

@@ -5,13 +5,36 @@
 
 namespace bitutil {
 
-/* Helper functions for manipulating the individual bits of a byte.
+// Helper functions for manipulating the individual bits of a byte.
-Position refers to n-th bit of a byte, going from 0 (most significant bit) to
+// Position refers to n-th bit of a byte, going from 0 (most significant bit) to
-7 (least significant bit) */
+// 7 (least significant bit)
-void bitSet(uint8_t* byte, uint8_t position);
+
-void bitToggle(uint8_t* byte, uint8_t position);
+/**
-void bitClear(uint8_t* byte, uint8_t position);
+ * @brief   Set the bit in a given byte
-bool bitGet(const uint8_t* byte, uint8_t position);
+ * @param byte
+ * @param position
+ */
+void set(uint8_t* byte, uint8_t position);
+/**
+ * @brief   Toggle the bit in a given byte
+ * @param byte
+ * @param position
+ */
+void toggle(uint8_t* byte, uint8_t position);
+/**
+ * @brief   Clear the bit in a given byte
+ * @param byte
+ * @param position
+ */
+void clear(uint8_t* byte, uint8_t position);
+/**
+ * @brief   Get the bit in a given byte
+ * @param byte
+ * @param position
+ * @param If the input is valid, this will be set to true if the bit is set and false otherwise.
+ * @return False if position is invalid, True otherwise
+ */
+bool get(const uint8_t* byte, uint8_t position, bool& bit);
 
 }
 

src/fsfw/globalfunctions/timevalOperations.h

@@ -2,8 +2,9 @@
 #define TIMEVALOPERATIONS_H_
 
 #include <stdint.h>
+#include <fsfw/platform.h>
 
-#ifdef WIN32
+#ifdef PLATFORM_WIN
 #include <winsock2.h>
 #else
 #include <sys/time.h>

src/fsfw/memory/FileSystemArgsIF.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_SRC_FSFW_MEMORY_FILESYSTEMARGS_H_
+#define FSFW_SRC_FSFW_MEMORY_FILESYSTEMARGS_H_
+
+/**
+ * Empty base interface which can be implemented by to pass arguments via the HasFileSystemIF.
+ * Users can then dynamic_cast the base pointer to the require child pointer.
+ */
+class FileSystemArgsIF {
+public:
+    virtual~ FileSystemArgsIF() {};
+};
+
+#endif /* FSFW_SRC_FSFW_MEMORY_FILESYSTEMARGS_H_ */

src/fsfw/memory/HasFileSystemIF.h

@@ -1,9 +1,10 @@
 #ifndef FSFW_MEMORY_HASFILESYSTEMIF_H_
 #define FSFW_MEMORY_HASFILESYSTEMIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "FileSystemArgsIF.h"
-#include "../returnvalues/FwClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/messageQueueDefinitions.h"
+#include "fsfw/returnvalues/FwClassIds.h"
+#include "fsfw/ipc/messageQueueDefinitions.h"
 
 #include <cstddef>
 
@@ -59,7 +60,7 @@ public:
 	 */
 	virtual ReturnValue_t appendToFile(const char* repositoryPath,
 	        const char* filename, const uint8_t* data, size_t size,
-	        uint16_t packetNumber, void* args = nullptr) = 0;
+	        uint16_t packetNumber, FileSystemArgsIF* args = nullptr) = 0;
 
 	/**
 	 * @brief   Generic function to create a new file.
@@ -72,7 +73,7 @@ public:
 	 */
 	virtual ReturnValue_t createFile(const char* repositoryPath,
 	        const char* filename, const uint8_t* data = nullptr,
-	        size_t size = 0, void* args = nullptr) = 0;
+	        size_t size = 0, FileSystemArgsIF* args = nullptr) = 0;
 
 	/**
 	 * @brief   Generic function to delete a file.
@@ -81,24 +82,30 @@ public:
 	 * @param args Any other arguments which an implementation might require
 	 * @return
 	 */
-	virtual ReturnValue_t deleteFile(const char* repositoryPath,
+	virtual ReturnValue_t removeFile(const char* repositoryPath,
-	        const char* filename, void* args = nullptr) = 0;
+	        const char* filename, FileSystemArgsIF* args = nullptr) = 0;
 
 	/**
 	 * @brief   Generic function to create a directory
 	 * @param repositoryPath
+	 * @param   Equivalent to the -p flag in Unix systems. If some required parent directories
+	 *          do not exist, create them as well
 	 * @param args Any other arguments which an implementation might require
 	 * @return
 	 */
-	virtual ReturnValue_t createDirectory(const char* repositoryPath, void* args = nullptr) = 0;
+	virtual ReturnValue_t createDirectory(const char* repositoryPath, const char* dirname,
+	        bool createParentDirs, FileSystemArgsIF* args = nullptr) = 0;
 
 	/**
 	 * @brief   Generic function to remove a directory
 	 * @param repositoryPath
      * @param args Any other arguments which an implementation might require
 	 */
-	virtual ReturnValue_t removeDirectory(const char* repositoryPath,
+	virtual ReturnValue_t removeDirectory(const char* repositoryPath, const char* dirname,
-	        bool deleteRecurively = false, void* args = nullptr) = 0;
+	        bool deleteRecurively = false, FileSystemArgsIF* args = nullptr) = 0;
+
+	virtual ReturnValue_t renameFile(const char* repositoryPath, const char* oldFilename,
+	        const char* newFilename, FileSystemArgsIF* args = nullptr) = 0;
 };
 
 

src/fsfw/osal/common/TcpTmTcServer.cpp

@@ -1,13 +1,17 @@
-#include "fsfw/osal/common/TcpTmTcServer.h"
-#include "fsfw/osal/common/TcpTmTcBridge.h"
-#include "fsfw/osal/common/tcpipHelpers.h"
-
 #include "fsfw/platform.h"
+#include "fsfw/FSFW.h"
+
+#include "TcpTmTcServer.h"
+#include "TcpTmTcBridge.h"
+#include "tcpipHelpers.h"
+
+#include "fsfw/tmtcservices/SpacePacketParser.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
 #include "fsfw/container/SharedRingBuffer.h"
 #include "fsfw/ipc/MessageQueueSenderIF.h"
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 
@@ -18,19 +22,14 @@
 #include <netdb.h>
 #endif
 
-#ifndef FSFW_TCP_RECV_WIRETAPPING_ENABLED
-#define FSFW_TCP_RECV_WIRETAPPING_ENABLED 0
-#endif
-
 const std::string TcpTmTcServer::DEFAULT_SERVER_PORT = tcpip::DEFAULT_SERVER_PORT;
 
 TcpTmTcServer::TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
-        size_t receptionBufferSize, std::string customTcpServerPort):
+        size_t receptionBufferSize, size_t ringBufferSize, std::string customTcpServerPort,
-        SystemObject(objectId), tmtcBridgeId(tmtcTcpBridge),
+        ReceptionModes receptionMode):
-        tcpPort(customTcpServerPort), receptionBuffer(receptionBufferSize) {
+        SystemObject(objectId), tmtcBridgeId(tmtcTcpBridge), receptionMode(receptionMode),
-    if(tcpPort == "") {
+        tcpConfig(customTcpServerPort), receptionBuffer(receptionBufferSize),
-        tcpPort = DEFAULT_SERVER_PORT;
+        ringBuffer(ringBufferSize, true) {
-    }
 }
 
 ReturnValue_t TcpTmTcServer::initialize() {
@@ -41,6 +40,17 @@ ReturnValue_t TcpTmTcServer::initialize() {
         return result;
     }
 
+    switch(receptionMode) {
+    case(ReceptionModes::SPACE_PACKETS): {
+        spacePacketParser = new SpacePacketParser(validPacketIds);
+        if(spacePacketParser == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+#if defined PLATFORM_UNIX
+        tcpConfig.tcpFlags |= MSG_DONTWAIT;
+#endif
+    }
+    }
     tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
     if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -63,7 +73,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
     hints.ai_flags = AI_PASSIVE;
 
     // Listen to all addresses (0.0.0.0) by using AI_PASSIVE in the hint flags
-    retval = getaddrinfo(nullptr, tcpPort.c_str(), &hints, &addrResult);
+    retval = getaddrinfo(nullptr, tcpConfig.tcpPort.c_str(), &hints, &addrResult);
     if (retval != 0) {
         handleError(Protocol::TCP, ErrorSources::GETADDRINFO_CALL);
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -105,7 +115,7 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
 
     // Listen for connection requests permanently for lifetime of program
     while(true) {
-        retval = listen(listenerTcpSocket, tcpBacklog);
+        retval = listen(listenerTcpSocket, tcpConfig.tcpBacklog);
         if(retval == SOCKET_ERROR) {
             handleError(Protocol::TCP, ErrorSources::LISTEN_CALL, 500);
             continue;
@@ -123,11 +133,12 @@ ReturnValue_t TcpTmTcServer::performOperation(uint8_t opCode) {
         handleServerOperation(connSocket);
 
         // Done, shut down connection and go back to listening for client requests
-        retval = shutdown(connSocket, SHUT_SEND);
+        retval = shutdown(connSocket, SHUT_BOTH);
         if(retval != 0) {
             handleError(Protocol::TCP, ErrorSources::SHUTDOWN_CALL);
         }
         closeSocket(connSocket);
+        connSocket = 0;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -144,41 +155,88 @@ ReturnValue_t TcpTmTcServer::initializeAfterTaskCreation() {
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-void TcpTmTcServer::handleServerOperation(socket_t connSocket) {
+void TcpTmTcServer::handleServerOperation(socket_t& connSocket) {
-    int retval = 0;
+#if defined PLATFORM_WIN
-    do {
+    setSocketNonBlocking(connSocket);
-        // Read all telecommands sent by the client
+#endif
-        retval = recv(connSocket,
+
+    while (true) {
+        int retval = recv(
+                connSocket,
                 reinterpret_cast<char*>(receptionBuffer.data()),
                 receptionBuffer.capacity(),
-                tcpFlags);
+                tcpConfig.tcpFlags
-        if (retval > 0) {
+        );
-            handleTcReception(retval);
+        if(retval == 0) {
+            size_t availableReadData = ringBuffer.getAvailableReadData();
+            if(availableReadData > lastRingBufferSize) {
+                handleTcRingBufferData(availableReadData);
+            }
+            return;
+        }
+        else if(retval > 0) {
+            // The ring buffer was configured for overwrite, so the returnvalue does not need to
+            // be checked for now
+            ringBuffer.writeData(receptionBuffer.data(), retval);
+        }
+        else if(retval < 0)  {
+            int errorValue = getLastSocketError();
+#if defined PLATFORM_UNIX
+            int wouldBlockValue = EAGAIN;
+#elif defined PLATFORM_WIN
+            int wouldBlockValue = WSAEWOULDBLOCK;
+#endif
+            if(errorValue == wouldBlockValue) {
+                // No data available. Check whether any packets have been read, then send back
+                // telemetry if available
+                bool tcAvailable = false;
+                bool tmSent = false;
+                size_t availableReadData = ringBuffer.getAvailableReadData();
+                if(availableReadData > lastRingBufferSize) {
+                    tcAvailable = true;
+                    handleTcRingBufferData(availableReadData);
+                }
+                ReturnValue_t result = handleTmSending(connSocket, tmSent);
+                if(result == CONN_BROKEN) {
+                    return;
+                }
+                if(not tcAvailable and not tmSent) {
+                    TaskFactory::delayTask(tcpConfig.tcpLoopDelay);
                 }
-        else if(retval == 0) {
-            // Client has finished sending telecommands, send telemetry now
-            handleTmSending(connSocket);
             }
             else {
-            // Should not happen
+                tcpip::handleError(tcpip::Protocol::TCP, tcpip::ErrorSources::RECV_CALL, 300);
-            tcpip::handleError(tcpip::Protocol::TCP, tcpip::ErrorSources::RECV_CALL);
+            }
+        }
     }
-    } while(retval > 0);
 }
 
-ReturnValue_t TcpTmTcServer::handleTcReception(size_t bytesRecvd) {
+ReturnValue_t TcpTmTcServer::handleTcReception(uint8_t* spacePacket, size_t packetSize) {
-#if FSFW_TCP_RECV_WIRETAPPING_ENABLED == 1
+    if(wiretappingEnabled) {
-    arrayprinter::print(receptionBuffer.data(), bytesRead);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "Received TC:" << std::endl;
+#else
+        sif::printInfo("Received TC:\n");
 #endif
+        arrayprinter::print(spacePacket, packetSize);
+    }
+
+    if(spacePacket == nullptr or packetSize == 0) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
     store_address_t storeId;
-    ReturnValue_t result = tcStore->addData(&storeId, receptionBuffer.data(), bytesRecvd);
+    ReturnValue_t result = tcStore->addData(&storeId, spacePacket, packetSize);
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning<< "TcpTmTcServer::handleServerOperation: Data storage failed." << std::endl;
+        sif::warning << "TcpTmTcServer::handleServerOperation: Data storage with packet size" <<
-        sif::warning << "Packet size: " << bytesRecvd << std::endl;
+                packetSize << " failed" << std::endl;
+#else
+        sif::printWarning("TcpTmTcServer::handleServerOperation: Data storage with packet size %d "
+                "failed\n", packetSize);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return result;
     }
 
     TmTcMessage message(storeId);
@@ -187,8 +245,11 @@ ReturnValue_t TcpTmTcServer::handleTcReception(size_t bytesRecvd) {
     if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "UdpTcPollingTask::handleSuccessfullTcRead: "
+        sif::warning << "TcpTmTcServer::handleServerOperation: "
                 " Sending message to queue failed" << std::endl;
+#else
+        sif::printWarning("TcpTmTcServer::handleServerOperation: "
+                " Sending message to queue failed\n");
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 #endif /* FSFW_VERBOSE_LEVEL >= 1 */
         tcStore->deleteData(storeId);
@@ -196,21 +257,26 @@ ReturnValue_t TcpTmTcServer::handleTcReception(size_t bytesRecvd) {
     return result;
 }
 
-void TcpTmTcServer::setTcpBacklog(uint8_t tcpBacklog) {
-    this->tcpBacklog = tcpBacklog;
-}
-
 std::string TcpTmTcServer::getTcpPort() const {
-    return tcpPort;
+    return tcpConfig.tcpPort;
 }
 
-ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket) {
+void TcpTmTcServer::setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds) {
+    this->validPacketIds = validPacketIds;
+}
+
+TcpTmTcServer::TcpConfig& TcpTmTcServer::getTcpConfigStruct() {
+    return tcpConfig;
+}
+
+ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket, bool& tmSent) {
     // Access to the FIFO is mutex protected because it is filled by the bridge
     MutexGuard(tmtcBridge->mutex, tmtcBridge->timeoutType, tmtcBridge->mutexTimeoutMs);
     store_address_t storeId;
     while((not tmtcBridge->tmFifo->empty()) and
             (tmtcBridge->packetSentCounter < tmtcBridge->sentPacketsPerCycle)) {
-        tmtcBridge->tmFifo->retrieve(&storeId);
+        // Send can fail, so only peek from the FIFO
+        tmtcBridge->tmFifo->peek(&storeId);
 
         // Using the store accessor will take care of deleting TM from the store automatically
         ConstStorageAccessor storeAccessor(storeId);
@@ -218,13 +284,134 @@ ReturnValue_t TcpTmTcServer::handleTmSending(socket_t connSocket) {
         if(result != HasReturnvaluesIF::RETURN_OK) {
             return result;
         }
+        if(wiretappingEnabled) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::info << "Sending TM:" << std::endl;
+#else
+            sif::printInfo("Sending TM:\n");
+#endif
+            arrayprinter::print(storeAccessor.data(), storeAccessor.size());
+        }
         int retval = send(connSocket,
                 reinterpret_cast<const char*>(storeAccessor.data()),
                 storeAccessor.size(),
-                tcpTmFlags);
+                tcpConfig.tcpTmFlags);
-        if(retval != static_cast<int>(storeAccessor.size())) {
+        if(retval == static_cast<int>(storeAccessor.size())) {
-            tcpip::handleError(tcpip::Protocol::TCP, tcpip::ErrorSources::SEND_CALL);
+            // Packet sent, clear FIFO entry
+            tmtcBridge->tmFifo->pop();
+            tmSent = true;
+
+        }
+        else if(retval <= 0) {
+            // Assume that the client has closed the connection here for now
+            handleSocketError(storeAccessor);
+            return CONN_BROKEN;
         }
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
+
+ReturnValue_t TcpTmTcServer::handleTcRingBufferData(size_t availableReadData) {
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t readAmount = availableReadData;
+    lastRingBufferSize = availableReadData;
+    if(readAmount >= ringBuffer.getMaxSize()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        // Possible configuration error, too much data or/and data coming in too fast,
+        // requiring larger buffers
+        sif::warning << "TcpTmTcServer::handleServerOperation: Ring buffer reached " <<
+                "fill count" << std::endl;
+#else
+        sif::printWarning("TcpTmTcServer::handleServerOperation: Ring buffer reached "
+                "fill count");
+#endif
+#endif
+    }
+    if(readAmount >= receptionBuffer.size()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        // Possible configuration error, too much data or/and data coming in too fast,
+        // requiring larger buffers
+        sif::warning << "TcpTmTcServer::handleServerOperation: "
+                "Reception buffer too small " << std::endl;
+#else
+        sif::printWarning("TcpTmTcServer::handleServerOperation: Reception buffer too small\n");
+#endif
+#endif
+        readAmount = receptionBuffer.size();
+    }
+    ringBuffer.readData(receptionBuffer.data(), readAmount, true);
+    const uint8_t* bufPtr = receptionBuffer.data();
+    const uint8_t** bufPtrPtr = &bufPtr;
+    size_t startIdx = 0;
+    size_t foundSize = 0;
+    size_t readLen = 0;
+    while(readLen < readAmount) {
+        result = spacePacketParser->parseSpacePackets(bufPtrPtr, readAmount,
+                startIdx, foundSize, readLen);
+        switch(result) {
+        case(SpacePacketParser::NO_PACKET_FOUND):
+        case(SpacePacketParser::SPLIT_PACKET): {
+            break;
+        }
+        case(HasReturnvaluesIF::RETURN_OK): {
+            result = handleTcReception(receptionBuffer.data() + startIdx, foundSize);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+        }
+        }
+        ringBuffer.deleteData(foundSize);
+        lastRingBufferSize = ringBuffer.getAvailableReadData();
+        std::memset(receptionBuffer.data() + startIdx, 0, foundSize);
+    }
+    return status;
+}
+
+void TcpTmTcServer::enableWiretapping(bool enable) {
+    this->wiretappingEnabled = enable;
+}
+
+void TcpTmTcServer::handleSocketError(ConstStorageAccessor &accessor) {
+    // Don't delete data
+    accessor.release();
+    auto socketError = getLastSocketError();
+    switch(socketError) {
+#if defined PLATFORM_WIN
+    case(WSAECONNRESET): {
+        // See https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send
+        // Remote client might have shut down connection
+        return;
+    }
+#else
+    case(EPIPE): {
+        // See https://man7.org/linux/man-pages/man2/send.2.html
+        // Remote client might have shut down connection
+        return;
+    }
+#endif
+    default: {
+        tcpip::handleError(tcpip::Protocol::TCP, tcpip::ErrorSources::SEND_CALL);
+    }
+    }
+}
+
+#if defined PLATFORM_WIN
+void TcpTmTcServer::setSocketNonBlocking(socket_t &connSocket) {
+    u_long iMode = 1;
+    int iResult = ioctlsocket(connSocket, FIONBIO, &iMode);
+    if(iResult != NO_ERROR) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "TcpTmTcServer::handleServerOperation: Setting socket"
+                " non-blocking failed with error " << iResult;
+#else
+        sif::printWarning("TcpTmTcServer::handleServerOperation: Setting socket"
+                " non-blocking failed with error %d\n", iResult);
+#endif
+#endif
+    }
+}
+#endif

src/fsfw/osal/common/TcpTmTcServer.h

@@ -6,6 +6,7 @@
 #include "fsfw/platform.h"
 #include "fsfw/osal/common/tcpipHelpers.h"
 #include "fsfw/ipc/messageQueueDefinitions.h"
+#include "fsfw/container/SimpleRingBuffer.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/objectmanager/frameworkObjects.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -20,6 +21,7 @@
 #include <vector>
 
 class TcpTmTcBridge;
+class SpacePacketParser;
 
 /**
  * @brief   TCP server implementation
@@ -42,9 +44,38 @@ class TcpTmTcServer:
         public TcpIpBase,
         public ExecutableObjectIF {
 public:
+    enum class ReceptionModes {
+        SPACE_PACKETS
+    };
+
+    struct TcpConfig {
+    public:
+        TcpConfig(std::string tcpPort): tcpPort(tcpPort) {}
+
+        /**
+         * Passed to the recv call
+         */
+        int tcpFlags = 0;
+        int tcpBacklog = 3;
+
+        /**
+         * If no telecommands packets are being received and no telemetry is being sent,
+         * the TCP server will delay periodically by this amount to decrease the CPU load
+         */
+        uint32_t tcpLoopDelay = DEFAULT_LOOP_DELAY_MS ;
+        /**
+         * Passed to the send call
+         */
+        int tcpTmFlags = 0;
+
+        const std::string tcpPort;
+    };
+
     static const std::string DEFAULT_SERVER_PORT;
 
     static constexpr size_t ETHERNET_MTU_SIZE = 1500;
+    static constexpr size_t RING_BUFFER_SIZE = ETHERNET_MTU_SIZE * 3;
+    static constexpr uint32_t DEFAULT_LOOP_DELAY_MS = 200;
 
     /**
      * TCP Server Constructor
@@ -55,11 +86,21 @@ public:
      * @param customTcpServerPort   The user can specify another port than the default (7301) here.
      */
     TcpTmTcServer(object_id_t objectId, object_id_t tmtcTcpBridge,
-            size_t receptionBufferSize = ETHERNET_MTU_SIZE + 1,
+            size_t receptionBufferSize = RING_BUFFER_SIZE,
-            std::string customTcpServerPort = "");
+            size_t ringBufferSize = RING_BUFFER_SIZE,
+            std::string customTcpServerPort = DEFAULT_SERVER_PORT,
+            ReceptionModes receptionMode = ReceptionModes::SPACE_PACKETS);
     virtual~ TcpTmTcServer();
 
-    void setTcpBacklog(uint8_t tcpBacklog);
+    void enableWiretapping(bool enable);
+
+    /**
+     * Get a handle to the TCP configuration struct, which can be used to configure TCP
+     * properties
+     * @return
+     */
+    TcpConfig& getTcpConfigStruct();
+    void setSpacePacketParsingOptions(std::vector<uint16_t> validPacketIds);
 
     ReturnValue_t initialize() override;
     ReturnValue_t performOperation(uint8_t opCode) override;
@@ -71,25 +112,33 @@ protected:
     StorageManagerIF* tcStore = nullptr;
     StorageManagerIF* tmStore = nullptr;
 private:
+    static constexpr ReturnValue_t CONN_BROKEN = HasReturnvaluesIF::makeReturnCode(1, 0);
     //! TMTC bridge is cached.
     object_id_t tmtcBridgeId = objects::NO_OBJECT;
     TcpTmTcBridge* tmtcBridge = nullptr;
+    bool wiretappingEnabled = false;
 
-    std::string tcpPort;
+    ReceptionModes receptionMode;
-    int tcpFlags = 0;
+    TcpConfig tcpConfig;
-    socket_t listenerTcpSocket = 0;
     struct sockaddr tcpAddress;
+    socket_t listenerTcpSocket = 0;
+
     MessageQueueId_t targetTcDestination = MessageQueueIF::NO_QUEUE;
-    int tcpAddrLen = sizeof(tcpAddress);
-    int tcpBacklog = 3;
 
     std::vector<uint8_t> receptionBuffer;
-    int tcpSockOpt = 0;
+    SimpleRingBuffer ringBuffer;
-    int tcpTmFlags = 0;
+    std::vector<uint16_t> validPacketIds;
+    SpacePacketParser* spacePacketParser = nullptr;
+    uint8_t lastRingBufferSize = 0;
 
-    void handleServerOperation(socket_t connSocket);
+    virtual void handleServerOperation(socket_t& connSocket);
-    ReturnValue_t handleTcReception(size_t bytesRecvd);
+    ReturnValue_t handleTcReception(uint8_t* spacePacket, size_t packetSize);
-    ReturnValue_t handleTmSending(socket_t connSocket);
+    ReturnValue_t handleTmSending(socket_t connSocket, bool& tmSent);
+    ReturnValue_t handleTcRingBufferData(size_t availableReadData);
+    void handleSocketError(ConstStorageAccessor& accessor);
+#if defined PLATFORM_WIN
+    void setSocketNonBlocking(socket_t& connSocket);
+#endif
 };
 
 #endif /* FSFW_OSAL_COMMON_TCP_TMTC_SERVER_H_ */

src/fsfw/osal/common/tcpipCommon.cpp

@@ -21,6 +21,9 @@ void tcpip::determineErrorStrings(Protocol protocol, ErrorSources errorSrc, std:
     if(errorSrc == ErrorSources::SETSOCKOPT_CALL) {
         srcString = "setsockopt call";
     }
+    if(errorSrc == ErrorSources::BIND_CALL) {
+        srcString = "bind call";
+    }
     else if(errorSrc == ErrorSources::SOCKET_CALL) {
         srcString = "socket call";
     }

src/fsfw/pus/Service5EventReporting.cpp

@@ -41,8 +41,7 @@ ReturnValue_t Service5EventReporting::performService() {
 	    }
 	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	sif::warning <<  "Service5EventReporting::generateEventReport: Too many events" << std::endl;
-	        " Too many events" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -64,8 +63,11 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "Service5EventReporting::generateEventReport:"
+		sif::warning << "Service5EventReporting::generateEventReport: "
-		        " Could not send TM packet" << std::endl;
+		        "Could not send TM packet" << std::endl;
+#else
+		sif::printWarning("Service5EventReporting::generateEventReport: "
+                "Could not send TM packet\n");
 #endif
 	}
 	return result;

src/fsfw/pus/Service8FunctionManagement.cpp

@@ -33,8 +33,8 @@ ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
 	if(tcDataLen < sizeof(object_id_t)) {
 		return CommandingServiceBase::INVALID_TC;
 	}
-	SerializeAdapter::deSerialize(objectId, &tcData,
+	// Can't fail, size was checked before
-			&tcDataLen, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
 
 	return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }

src/fsfw/returnvalues/FwClassIds.h

@@ -80,6 +80,7 @@ enum: uint8_t {
     FIXED_SLOT_TASK_IF, //FTIF
     MGM_LIS3MDL, //MGMLIS3
     MGM_RM3100, //MGMRM3100
+    SPACE_PACKET_PARSER, //SPPA
     FW_CLASS_ID_COUNT // [EXPORT] : [END]
 
 };

src/fsfw/returnvalues/HasReturnvaluesIF.h

@@ -22,9 +22,9 @@ public:
 	 * @param number
 	 * @return
 	 */
-	static constexpr ReturnValue_t makeReturnCode(uint8_t interfaceId,
+	static constexpr ReturnValue_t makeReturnCode(uint8_t classId,
 			uint8_t number) {
-	    return (static_cast<ReturnValue_t>(interfaceId) << 8) + number;
+	    return (static_cast<ReturnValue_t>(classId) << 8) + number;
 	}
 };
 

src/fsfw/serialize/SerializeAdapter.h

@@ -7,7 +7,7 @@
 #include <cstddef>
 #include <type_traits>
 
- /**
+/**
  * @brief These adapters provides an interface to use the SerializeIF functions
  * 		  with arbitrary template objects to facilitate and simplify the
  * 		  serialization of classes with different multiple different data types
@@ -21,18 +21,21 @@
 class SerializeAdapter {
 public:
     /***
-	 * This function can be used to serialize a trivial copy-able type or a
+     * @brief   Serialize a trivial copy-able type or a child of SerializeIF.
-	 * child of SerializeIF.
+     * @details
      * The right template to be called is determined in the function itself.
      * For objects of non trivial copy-able type this function is almost never
      * called by the user directly. Instead helpers for specific types like
-	 * SerialArrayListAdapter or SerialLinkedListAdapter is the right choice here.
+     * SerialArrayListAdapter or SerialLinkedListAdapter are the right choice here.
      *
-	 * @param[in] object Object to serialize, the used type is deduced from this pointer
+     * @param[in] object: Object to serialize, the used type is deduced from this pointer
-	 * @param[in/out] buffer Buffer to serialize into. Will be moved by the function.
+     * @param[in/out] buffer: Pointer to the buffer to serialize into. Buffer position will be
-	 * @param[in/out] size Size of current written buffer. Will be incremented by the function.
+     *     incremented by the function.
-	 * @param[in] maxSize Max size of Buffer
+     * @param[in/out] size: Pointer to size of current written buffer.
-	 * @param[in] streamEndianness Endianness of serialized element as in according to SerializeIF::Endianness
+     *     SIze will be incremented by the function.
+     * @param[in] maxSize: Max size of Buffer
+     * @param[in] streamEndianness: Endianness of serialized element as in according to
+     *     SerializeIF::Endianness
      * @return
      * 		- @c BUFFER_TOO_SHORT The given buffer in is too short
      * 		- @c RETURN_FAILED Generic Error
@@ -46,9 +49,46 @@ public:
         return adapter.serialize(object, buffer, size, maxSize,
                 streamEndianness);
     }
+
+    /***
+     * This function can be used to serialize a trivial copy-able type or a child of SerializeIF.
+     * The right template to be called is determined in the function itself.
+     * For objects of non trivial copy-able type this function is almost never
+     * called by the user directly. Instead helpers for specific types like
+     * SerialArrayListAdapter or SerialLinkedListAdapter are the right choice here.
+     *
+     * @param[in] object: Object to serialize, the used type is deduced from this pointer
+     * @param[in/out] buffer: Buffer to serialize into.
+     * @param[out] serSize: Serialized size
+     * @param[in] maxSize: Max size of buffer
+     * @param[in] streamEndianness: Endianness of serialized element as in according to
+     *     SerializeIF::Endianness
+     * @return
+     *      - @c BUFFER_TOO_SHORT The given buffer in is too short
+     *      - @c RETURN_FAILED Generic Error
+     *      - @c RETURN_OK Successful serialization
+     */
+    template<typename T>
+    static ReturnValue_t serialize(const T *object, uint8_t* const buffer, size_t* serSize,
+            size_t maxSize, SerializeIF::Endianness streamEndianness) {
+        if(object == nullptr or buffer == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
+        uint8_t** tempPtr = const_cast<uint8_t**>(&buffer);
+        size_t tmpSize = 0;
+        ReturnValue_t result = adapter.serialize(object, tempPtr, &tmpSize, maxSize,
+                streamEndianness);
+        if(serSize != nullptr) {
+            *serSize = tmpSize;
+        }
+        return result;
+    }
+
     /**
-	 * Function to return the serialized size of the object in the pointer.
+     * @brief   Function to return the serialized size of the object in the pointer.
-	 * May be a trivially copy-able object or a Child of SerializeIF
+     * @details
+     * May be a trivially copy-able object or a child of SerializeIF.
      *
      * @param object Pointer to Object
      * @return Serialized size of object
@@ -58,17 +98,20 @@ public:
         InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
         return adapter.getSerializedSize(object);
     }
+
     /**
-	 * @brief
+     * @brief Deserializes a object from a given buffer of given size.
-	 * Deserializes a object from a given buffer of given size.
-	 * Object Must be trivially copy-able or a child of SerializeIF.
      *
      * @details
+     * Object Must be trivially copy-able or a child of SerializeIF.
      * Buffer will be moved to the current read location. Size will be decreased by the function.
      *
-	 * @param[in/out] buffer Buffer to deSerialize from. Will be moved by the function.
+     * @param[in] object:        Pointer to object to deserialize
-	 * @param[in/out] size Remaining size of the buffer to read from. Will be decreased by function.
+     * @param[in/out] buffer:    Pointer to the buffer to deSerialize from. Buffer position will be
-	 * @param[in] streamEndianness Endianness as in according to SerializeIF::Endianness
+     *     incremented by the function
+     * @param[in/out] size:      Pointer to remaining size of the buffer to read from.
+     *     Will be decreased by function.
+     * @param[in] streamEndianness: Endianness as in according to SerializeIF::Endianness
      * @return
      * 	- @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
      * 	- @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
@@ -81,6 +124,39 @@ public:
         InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
         return adapter.deSerialize(object, buffer, size, streamEndianness);
     }
+
+    /**
+     * @brief Deserializes a object from a given buffer of given size.
+     *
+     * @details
+     * Object Must be trivially copy-able or a child of SerializeIF.
+     *
+     * @param[in] object:        Pointer to object to deserialize
+     * @param[in] buffer:    Buffer to deSerialize from
+     * @param[out] deserSize:    Deserialized length
+     * @param[in] streamEndianness: Endianness as in according to SerializeIF::Endianness
+     * @return
+     *  - @c STREAM_TOO_SHORT The input stream is too short to deSerialize the object
+     *  - @c TOO_MANY_ELEMENTS The buffer has more inputs than expected
+     *  - @c RETURN_FAILED Generic Error
+     *  - @c RETURN_OK Successful deserialization
+     */
+    template<typename T>
+    static ReturnValue_t deSerialize(T *object, const uint8_t* buffer,
+            size_t* deserSize, SerializeIF::Endianness streamEndianness) {
+        if(object == nullptr or buffer == nullptr) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
+        const uint8_t** tempPtr = &buffer;
+        size_t maxVal = -1;
+        ReturnValue_t result = adapter.deSerialize(object, tempPtr, &maxVal, streamEndianness);
+        if(deserSize != nullptr) {
+            *deserSize = -1 - maxVal;
+        }
+        return result;
+    }
+
 private:
     /**
      * Internal template to deduce the right function calls at compile time

src/fsfw/tcdistribution/PUSDistributor.cpp

@@ -29,12 +29,28 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
         tcStatus = checker.checkPacket(currentPacket);
         if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
+            const char* keyword = "unnamed error";
+            if(tcStatus == TcPacketCheck::INCORRECT_CHECKSUM) {
+                keyword = "checksum";
+            }
+            else if(tcStatus == TcPacketCheck::INCORRECT_PRIMARY_HEADER) {
+                keyword = "incorrect primary header";
+            }
+            else if(tcStatus == TcPacketCheck::ILLEGAL_APID) {
+                keyword = "illegal APID";
+            }
+            else if(tcStatus == TcPacketCheck::INCORRECT_SECONDARY_HEADER) {
+                keyword = "incorrect secondary header";
+            }
+            else if(tcStatus == TcPacketCheck::INCOMPLETE_PACKET) {
+                keyword = "incomplete packet";
+            }
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::debug << "PUSDistributor::handlePacket: Packet format invalid, code " <<
+            sif::warning << "PUSDistributor::handlePacket: Packet format invalid, "
-                    static_cast<int>(tcStatus) << std::endl;
+                    << keyword << " error" << std::endl;
 #else
-            sif::printDebug("PUSDistributor::handlePacket: Packet format invalid, code %d\n",
+            sif::printWarning("PUSDistributor::handlePacket: Packet format invalid, "
-                    static_cast<int>(tcStatus));
+                    "%s error\n", keyword);
 #endif
 #endif
         }

src/fsfw/tmtcpacket/SpacePacket.h

@@ -40,6 +40,7 @@ public:
      * 			@li \c false else.
      */
     bool addWholeData(const uint8_t* p_data, uint32_t packet_size);
+
 protected:
     /**
      * This structure defines the data structure of a Space Packet as local data.
@@ -68,4 +69,24 @@ protected:
     SpacePacketData localData;
 };
 
+namespace spacepacket {
+
+constexpr uint16_t getSpacePacketIdFromApid(bool isTc, uint16_t apid,
+        bool secondaryHeaderFlag = true) {
+    return ((isTc << 4) | (secondaryHeaderFlag << 3) |
+            ((apid >> 8) & 0x07)) << 8 | (apid & 0x00ff);
+}
+
+constexpr uint16_t getTcSpacePacketIdFromApid(uint16_t apid,
+        bool secondaryHeaderFlag = true) {
+    return getSpacePacketIdFromApid(true, apid, secondaryHeaderFlag);
+}
+
+constexpr uint16_t getTmSpacePacketIdFromApid(uint16_t apid,
+        bool secondaryHeaderFlag = true) {
+    return getSpacePacketIdFromApid(false, apid, secondaryHeaderFlag);
+}
+
+}
+
 #endif /* SPACEPACKET_H_ */

src/fsfw/tmtcpacket/pus/tm/TmPacketStoredBase.cpp

@@ -118,7 +118,7 @@ void TmPacketStoredBase::handleStoreFailure(const char *const packetType, Return
                 "%d too large\n", packetType, sizeToReserve);
         break;
     }
-#endif
 #endif
     }
+#endif
 }

src/fsfw/tmtcservices/CMakeLists.txt

@@ -6,4 +6,5 @@ target_sources(${LIB_FSFW_NAME}
 		TmTcBridge.cpp
 		TmTcMessage.cpp
 		VerificationReporter.cpp
+		SpacePacketParser.cpp
 )

src/fsfw/tmtcservices/SpacePacketParser.cpp

@@ -0,0 +1,77 @@
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tmtcservices/SpacePacketParser.h>
+#include <algorithm>
+
+SpacePacketParser::SpacePacketParser(std::vector<uint16_t> validPacketIds):
+        validPacketIds(validPacketIds) {
+}
+
+ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t *buffer,
+        const size_t maxSize, size_t& startIndex, size_t& foundSize) {
+    const uint8_t** tempPtr = &buffer;
+    size_t readLen = 0;
+    return parseSpacePackets(tempPtr, maxSize, startIndex, foundSize, readLen);
+}
+
+ReturnValue_t SpacePacketParser::parseSpacePackets(const uint8_t **buffer, const size_t maxSize,
+        size_t &startIndex, size_t &foundSize, size_t& readLen) {
+    if(buffer == nullptr or maxSize < 5) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpacePacketParser::parseSpacePackets: Frame invalid" << std::endl;
+#else
+        sif::printWarning("SpacePacketParser::parseSpacePackets: Frame invalid\n");
+#endif
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    const uint8_t* bufPtr = *buffer;
+
+    auto verifyLengthField = [&](size_t idx) {
+        uint16_t lengthField = bufPtr[idx + 4] << 8 | bufPtr[idx + 5];
+        size_t packetSize = lengthField + 7;
+        startIndex = idx;
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        if(lengthField == 0) {
+            // Skip whole header for now
+            foundSize = 6;
+            result = NO_PACKET_FOUND;
+        }
+        else if(packetSize + idx > maxSize) {
+            // Don't increment buffer and read length here, user has to decide what to do
+            foundSize = packetSize;
+            return SPLIT_PACKET;
+        }
+        else {
+            foundSize = packetSize;
+        }
+        *buffer += foundSize;
+        readLen += idx + foundSize;
+        return result;
+    };
+
+    size_t idx = 0;
+    // Space packet ID as start marker
+    if(validPacketIds.size() > 0) {
+        while(idx < maxSize - 5) {
+            uint16_t currentPacketId = bufPtr[idx] << 8 | bufPtr[idx + 1];
+            if(std::find(validPacketIds.begin(), validPacketIds.end(), currentPacketId) !=
+                    validPacketIds.end()) {
+                if(idx + 5 >= maxSize) {
+                    return SPLIT_PACKET;
+                }
+                return verifyLengthField(idx);
+            }
+            else {
+                idx++;
+            }
+        }
+        startIndex = 0;
+        foundSize = maxSize;
+        *buffer += foundSize;
+        readLen += foundSize;
+        return NO_PACKET_FOUND;
+    }
+    // Assume that the user verified a valid start of a space packet
+    else {
+        return verifyLengthField(idx);
+    }
+}

src/fsfw/tmtcservices/SpacePacketParser.h

@@ -0,0 +1,78 @@
+#ifndef FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+#define FRAMEWORK_TMTCSERVICES_PUSPARSER_H_
+
+#include "fsfw/container/DynamicFIFO.h"
+#include "fsfw/returnvalues/FwClassIds.h"
+
+#include <utility>
+#include <cstdint>
+
+/**
+ * @brief	This small helper class scans a given buffer for space packets.
+ * 			Can be used if space packets are serialized in a tightly packed frame.
+ * @details
+ * The parser uses the length field field and the 16-bit TC packet ID of the space packets to find
+ * find space packets in a given data stream
+ * @author   R. Mueller
+ */
+class SpacePacketParser {
+public:
+	//! The first entry is the index inside the buffer while the second index
+	//! is the size of the PUS packet starting at that index.
+	using IndexSizePair = std::pair<size_t, size_t>;
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::SPACE_PACKET_PARSER;
+	static constexpr ReturnValue_t NO_PACKET_FOUND = MAKE_RETURN_CODE(0x00);
+	static constexpr ReturnValue_t SPLIT_PACKET = MAKE_RETURN_CODE(0x01);
+
+	/**
+	 * @brief   Parser constructor.
+	 * @param validPacketIds    This vector contains the allowed 16-bit TC packet ID start markers
+	 * The parser will search for these stark markers to detect the start of a space packet.
+	 * It is also possible to pass an empty vector here, but this is not recommended.
+	 * If an empty vector is passed, the parser will assume that the start of the given stream
+	 * contains the start of a new space packet.
+	 */
+	SpacePacketParser(std::vector<uint16_t> validPacketIds);
+
+    /**
+     * Parse a given frame for space packets but also increment the given buffer and assign the
+     * total number of bytes read so far
+     * @param buffer        Parser will look for space packets in this buffer
+     * @param maxSize       Maximum size of the buffer
+     * @param startIndex    Start index of a found space packet
+     * @param foundSize     Found size of the space packet
+     * @param readLen       Length read so far. This value is incremented by the number of parsed
+     *                      bytes which also includes the size of a found packet
+     *  -@c NO_PACKET_FOUND if no packet was found in the given buffer or the length field is
+     *      invalid. foundSize will be set to the size of the space packet header. buffer and
+     *      readLen will be incremented accordingly.
+     *  -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. foundSize
+     *      will be set to the detected packet size and startIndex will be set to the start of the
+     *      detected packet. buffer and read length will not be incremented but the found length
+     *      will be assigned.
+     *  -@c RETURN_OK if a packet was found
+     */
+    ReturnValue_t parseSpacePackets(const uint8_t **buffer, const size_t maxSize,
+            size_t& startIndex, size_t& foundSize, size_t& readLen);
+
+	/**
+	 * Parse a given frame for space packets
+	 * @param buffer        Parser will look for space packets in this buffer
+	 * @param maxSize       Maximum size of the buffer
+	 * @param startIndex    Start index of a found space packet
+	 * @param foundSize     Found size of the space packet
+	 *  -@c NO_PACKET_FOUND if no packet was found in the given buffer or the length field is
+	 *      invalid. foundSize will be set to the size of the space packet header
+	 *  -@c SPLIT_PACKET if a packet was found but the detected size exceeds maxSize. foundSize
+	 *      will be set to the detected packet size and startIndex will be set to the start of the
+	 *      detected packet
+	 *  -@c RETURN_OK if a packet was found
+	 */
+	ReturnValue_t parseSpacePackets(const uint8_t* buffer, const size_t maxSize,
+	        size_t& startIndex, size_t& foundSize);
+private:
+	std::vector<uint16_t> validPacketIds;
+};
+
+#endif /* FRAMEWORK_TMTCSERVICES_PUSPARSER_H_ */

tests/src/fsfw_tests/CMakeLists.txt

@@ -1,8 +1,9 @@
-
 if(FSFW_ADD_INTERNAL_TESTS)
     add_subdirectory(internal)
 endif()
 
-if(FSFW_ADD_UNITTESTS)
+if(FSFW_BUILD_UNITTESTS)
     add_subdirectory(unit)
+else()
+    add_subdirectory(integration)
 endif()

tests/src/fsfw_tests/integration/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_subdirectory(assemblies)
+add_subdirectory(controller)
+add_subdirectory(devices)
+add_subdirectory(task)

tests/src/fsfw_tests/integration/assemblies/CMakeLists.txt

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

tests/src/fsfw_tests/integration/assemblies/TestAssembly.cpp

@@ -0,0 +1,201 @@
+#include "TestAssembly.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+
+
+TestAssembly::TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+        object_id_t testDevice1):
+        AssemblyBase(objectId, parentId), deviceHandler0Id(testDevice0),
+        deviceHandler1Id(testDevice1) {
+	ModeListEntry newModeListEntry;
+	newModeListEntry.setObject(testDevice0);
+	newModeListEntry.setMode(MODE_OFF);
+	newModeListEntry.setSubmode(SUBMODE_NONE);
+
+	commandTable.insert(newModeListEntry);
+
+	newModeListEntry.setObject(testDevice1);
+	newModeListEntry.setMode(MODE_OFF);
+	newModeListEntry.setSubmode(SUBMODE_NONE);
+
+	commandTable.insert(newModeListEntry);
+
+}
+
+TestAssembly::~TestAssembly() {
+}
+
+ReturnValue_t TestAssembly::commandChildren(Mode_t mode,
+		Submode_t submode) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "TestAssembly: Received command to go to mode " << mode <<
+            " submode " << (int) submode << std::endl;
+#else
+    sif::printInfo("TestAssembly: Received command to go to mode %d submode %d\n", mode, submode);
+#endif
+	ReturnValue_t result = RETURN_OK;
+	if(mode == MODE_OFF){
+		commandTable[0].setMode(MODE_OFF);
+		commandTable[0].setSubmode(SUBMODE_NONE);
+		commandTable[1].setMode(MODE_OFF);
+		commandTable[1].setSubmode(SUBMODE_NONE);
+	}
+	else if(mode == DeviceHandlerIF::MODE_NORMAL) {
+		if(submode == submodes::SINGLE){
+			commandTable[0].setMode(MODE_OFF);
+			commandTable[0].setSubmode(SUBMODE_NONE);
+			commandTable[1].setMode(MODE_OFF);
+			commandTable[1].setSubmode(SUBMODE_NONE);
+			// We try to prefer 0 here but we try to switch to 1 even if it might fail
+			if(isDeviceAvailable(deviceHandler0Id)) {
+				if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+					commandTable[0].setMode(mode);
+					commandTable[0].setSubmode(SUBMODE_NONE);
+				}
+				else {
+					commandTable[0].setMode(MODE_ON);
+					commandTable[0].setSubmode(SUBMODE_NONE);
+				    result = NEED_SECOND_STEP;
+				}
+			}
+			else {
+				if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+					commandTable[1].setMode(mode);
+					commandTable[1].setSubmode(SUBMODE_NONE);
+				}
+				else{
+					commandTable[1].setMode(MODE_ON);
+					commandTable[1].setSubmode(SUBMODE_NONE);
+				    result = NEED_SECOND_STEP;
+				}
+			}
+		}
+		else{
+			// Dual Mode Normal
+			if (childrenMap[deviceHandler0Id].mode == MODE_ON) {
+				commandTable[0].setMode(mode);
+				commandTable[0].setSubmode(SUBMODE_NONE);
+			}
+			else{
+				commandTable[0].setMode(MODE_ON);
+				commandTable[0].setSubmode(SUBMODE_NONE);
+			    result = NEED_SECOND_STEP;
+			}
+			if (childrenMap[deviceHandler1Id].mode == MODE_ON) {
+				commandTable[1].setMode(mode);
+				commandTable[1].setSubmode(SUBMODE_NONE);
+			}
+			else{
+				commandTable[1].setMode(MODE_ON);
+				commandTable[1].setSubmode(SUBMODE_NONE);
+			    result = NEED_SECOND_STEP;
+			}
+		}
+	}
+	else{
+		//Mode ON
+		if(submode == submodes::SINGLE){
+			commandTable[0].setMode(MODE_OFF);
+			commandTable[0].setSubmode(SUBMODE_NONE);
+			commandTable[1].setMode(MODE_OFF);
+			commandTable[1].setSubmode(SUBMODE_NONE);
+			// We try to prefer 0 here but we try to switch to 1 even if it might fail
+			if(isDeviceAvailable(deviceHandler0Id)){
+				commandTable[0].setMode(MODE_ON);
+				commandTable[0].setSubmode(SUBMODE_NONE);
+			}
+			else{
+				commandTable[1].setMode(MODE_ON);
+				commandTable[1].setSubmode(SUBMODE_NONE);
+			}
+		}
+		else{
+			commandTable[0].setMode(MODE_ON);
+			commandTable[0].setSubmode(SUBMODE_NONE);
+			commandTable[1].setMode(MODE_ON);
+			commandTable[1].setSubmode(SUBMODE_NONE);
+		}
+	}
+
+
+
+	HybridIterator<ModeListEntry> iter(commandTable.begin(),
+			commandTable.end());
+	executeTable(iter);
+	return result;
+}
+
+ReturnValue_t TestAssembly::isModeCombinationValid(Mode_t mode,
+		Submode_t submode) {
+	switch (mode) {
+	case MODE_OFF:
+		if (submode == SUBMODE_NONE) {
+			return RETURN_OK;
+		} else {
+			return INVALID_SUBMODE;
+		}
+	case DeviceHandlerIF::MODE_NORMAL:
+	case MODE_ON:
+		if (submode < 3) {
+			return RETURN_OK;
+		} else {
+			return INVALID_SUBMODE;
+		}
+	}
+	return INVALID_MODE;
+}
+
+ReturnValue_t TestAssembly::initialize() {
+	ReturnValue_t result = AssemblyBase::initialize();
+	if(result != RETURN_OK){
+		return result;
+	}
+	handler0 = ObjectManager::instance()->get<TestDevice>(deviceHandler0Id);
+	handler1 = ObjectManager::instance()->get<TestDevice>(deviceHandler1Id);
+	if((handler0 == nullptr) or (handler1 == nullptr)){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	handler0->setParentQueue(this->getCommandQueue());
+	handler1->setParentQueue(this->getCommandQueue());
+
+
+	result = registerChild(deviceHandler0Id);
+		if (result != HasReturnvaluesIF::RETURN_OK) {
+			return result;
+		}
+	result = registerChild(deviceHandler1Id);
+	if (result != HasReturnvaluesIF::RETURN_OK) {
+		return result;
+	}
+	return result;
+}
+
+ReturnValue_t TestAssembly::checkChildrenStateOn(
+		Mode_t wantedMode, Submode_t wantedSubmode) {
+	if(submode == submodes::DUAL){
+		for(const auto& info:childrenMap) {
+			if(info.second.mode != wantedMode or info.second.mode != wantedSubmode){
+				return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
+			}
+		}
+		return RETURN_OK;
+	}
+	else if(submode == submodes::SINGLE) {
+		for(const auto& info:childrenMap) {
+			if(info.second.mode == wantedMode and info.second.mode != wantedSubmode){
+				return RETURN_OK;
+			}
+		}
+	}
+	return INVALID_SUBMODE;
+}
+
+bool TestAssembly::isDeviceAvailable(object_id_t object) {
+	if(healthHelper.healthTable->getHealth(object) == HasHealthIF::HEALTHY){
+		return true;
+	}
+	else{
+		return false;
+	}
+}

tests/src/fsfw_tests/integration/assemblies/TestAssembly.h

@@ -0,0 +1,56 @@
+#ifndef MISSION_ASSEMBLIES_TESTASSEMBLY_H_
+#define MISSION_ASSEMBLIES_TESTASSEMBLY_H_
+
+#include <fsfw/devicehandlers/AssemblyBase.h>
+#include "../devices/TestDeviceHandler.h"
+
+class TestAssembly: public AssemblyBase {
+public:
+	TestAssembly(object_id_t objectId, object_id_t parentId, object_id_t testDevice0,
+	        object_id_t testDevice1);
+	virtual ~TestAssembly();
+	ReturnValue_t initialize() override;
+
+	enum submodes: Submode_t{
+		SINGLE = 0,
+		DUAL = 1
+	};
+
+protected:
+	/**
+	 * Command children to reach [mode,submode] combination
+	 * Can be done by setting #commandsOutstanding correctly,
+	 * or using executeTable()
+	 * @param mode
+	 * @param submode
+	 * @return
+	 *    - @c RETURN_OK if ok
+	 *    - @c NEED_SECOND_STEP if children need to be commanded again
+	 */
+	ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
+    /**
+     * Check whether desired assembly mode was achieved by checking the modes
+     * or/and health states of child device handlers.
+     * The assembly template class will also call this function if a health
+     * or mode change of a child device handler was detected.
+     * @param wantedMode
+     * @param wantedSubmode
+     * @return
+     */
+	ReturnValue_t isModeCombinationValid(Mode_t mode, Submode_t submode)
+			override;
+
+	ReturnValue_t checkChildrenStateOn(Mode_t wantedMode,
+			Submode_t wantedSubmode) override;
+private:
+	FixedArrayList<ModeListEntry, 2> commandTable;
+	object_id_t deviceHandler0Id = 0;
+	object_id_t deviceHandler1Id = 0;
+	TestDevice* handler0 = nullptr;
+	TestDevice* handler1 = nullptr;
+
+
+	bool isDeviceAvailable(object_id_t object);
+};
+
+#endif /* MISSION_ASSEMBLIES_TESTASSEMBLY_H_ */

tests/src/fsfw_tests/integration/controller/CMakeLists.txt

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

tests/src/fsfw_tests/integration/controller/TestController.cpp

@@ -0,0 +1,48 @@
+#include "TestController.h"
+
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+TestController::TestController(object_id_t objectId,  object_id_t parentId,
+        size_t commandQueueDepth):
+        ExtendedControllerBase(objectId, parentId, commandQueueDepth) {
+}
+
+TestController::~TestController() {
+}
+
+ReturnValue_t TestController::handleCommandMessage(CommandMessage *message) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void TestController::performControlOperation() {
+
+}
+
+void TestController::handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) {
+
+}
+
+void TestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+        bool* clearMessage) {
+}
+
+LocalPoolDataSetBase* TestController::getDataSetHandle(sid_t sid) {
+    return nullptr;
+}
+
+ReturnValue_t TestController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+        LocalDataPoolManager &poolManager) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t TestController::initializeAfterTaskCreation() {
+    return ExtendedControllerBase::initializeAfterTaskCreation();
+}
+
+ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode,
+        uint32_t *msToReachTheMode) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+

tests/src/fsfw_tests/integration/controller/TestController.h

@@ -0,0 +1,38 @@
+#ifndef MISSION_CONTROLLER_TESTCONTROLLER_H_
+#define MISSION_CONTROLLER_TESTCONTROLLER_H_
+
+#include "../devices/devicedefinitions/testDeviceDefinitions.h"
+#include <fsfw/controller/ExtendedControllerBase.h>
+
+
+class TestController:
+        public ExtendedControllerBase {
+public:
+    TestController(object_id_t objectId, object_id_t parentId, size_t commandQueueDepth = 10);
+    virtual~ TestController();
+protected:
+
+    // Extended Controller Base overrides
+    ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+    void performControlOperation() override;
+
+    // HasLocalDatapoolIF callbacks
+    virtual void handleChangedDataset(sid_t sid, store_address_t storeId,
+            bool* clearMessage) override;
+    virtual void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+            bool* clearMessage) override;
+
+    LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                LocalDataPoolManager& poolManager) override;
+
+    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+            uint32_t *msToReachTheMode) override;
+
+    ReturnValue_t initializeAfterTaskCreation() override;
+
+private:
+};
+
+
+#endif /* MISSION_CONTROLLER_TESTCONTROLLER_H_ */