using new docker container name

Reviewed-on: #160
Reviewed-by: Jakob.Meier <meierj@irs.uni-stuttgart.de>

.clang-format

@@ -0,0 +1,8 @@
+---
+BasedOnStyle: Google
+IndentWidth: 2
+---
+Language: Cpp
+ColumnLimit: 100
+ReflowComments: true
+---

.gitignore

@@ -8,6 +8,9 @@
 !misc/eclipse/**/.cproject
 !misc/eclipse/**/.project
 
+#vscode
+/.vscode
+
 # Python
 __pycache__
 .idea

CMakeLists.txt

@@ -13,34 +13,32 @@ cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-if(TGT_BSP MATCHES "arm/q7s")
-    option(EIVE_BUILD_WATCHDOG "Compile the OBSW watchdog insted" OFF)
-    option(BUILD_Q7S_SIMPLE_MODE OFF "Simple mode with a minimal main function")
-endif()
 
-option(ADD_ETL_LIB "Add ETL library" ON)
-option(ADD_JSON_LIB "Add JSON library" ON)
+option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
+option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
+
 option(EIVE_SYSROOT_MAGIC "Perform sysroot magic which might not be necessary" OFF)
+option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name" ON)
 
 if(NOT FSFW_OSAL)
-	set(FSFW_OSAL host CACHE STRING "OS for the FSFW.")
+	set(FSFW_OSAL linux CACHE STRING "OS for the FSFW.")
 endif()
 
+if(TGT_BSP)
     if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
         option(LINUX_CROSS_COMPILE ON)
+        option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" OFF)
+    elseif(TGT_BSP MATCHES "arm/q7s")
+        option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" ON)
+    endif()
 endif()
 
 # Perform steps like loading toolchain files where applicable.
 include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
 pre_project_config()
 
-set(PROJECT_NAME_TO_SET eive-obsw-$ENV{USERNAME})
-if(EIVE_BUILD_WATCHDOG)
-    set(PROJECT_NAME_TO_SET eive-watchdog)
-endif()
-
 # Project Name
-project(${PROJECT_NAME_TO_SET} ASM C CXX)
+project(eive-obsw ASM C CXX)
 
 ################################################################################
 # Pre-Sources preparation
@@ -51,34 +49,42 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
 # Set names and variables
-set(TARGET_NAME ${CMAKE_PROJECT_NAME}) 
+set(OBSW_NAME ${CMAKE_PROJECT_NAME})
+set(WATCHDOG_NAME eive-watchdog)
+set(SIMPLE_OBSW_NAME eive-simple)
+set(UNITTEST_NAME eive-unittest)
 set(LIB_FSFW_NAME fsfw)
+set(LIB_EIVE_MISSION eive-mission)
 set(LIB_ETL_NAME etl)
 set(LIB_CSP_NAME libcsp)
 set(LIB_LWGPS_NAME lwgps)
 set(LIB_ARCSEC wire)
 set(THIRD_PARTY_FOLDER thirdparty)
 set(LIB_CXX_FS -lstdc++fs)
+set(LIB_CATCH2 Catch2)
+set(LIB_GPS gps)
 set(LIB_JSON_NAME nlohmann_json::nlohmann_json)
 
 # Set path names
 set(FSFW_PATH fsfw)
-set(MISSION_PATH mission)
 set(TEST_PATH test/testtasks)
+set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
 set(COMMON_PATH common)
 set(WATCHDOG_PATH watchdog)
 set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
+set(UNITTEST_CFG_PATH ${UNITTEST_PATH}/testcfg)
 
-set(FSFW_HAL_LIB_PATH fsfw_hal)
-set(CSP_LIB_PATH ${THIRD_PARTY_FOLDER}/libcsp)
-set(ETL_LIB_PATH ${THIRD_PARTY_FOLDER}/etl)
-set(LWGPS_LIB_PATH ${THIRD_PARTY_FOLDER}/lwgps)
-set(ARCSEC_LIB_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
+set(LIB_EIVE_MISSION_PATH mission)
+set(LIB_CSP_PATH ${THIRD_PARTY_FOLDER}/libcsp)
+set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
+set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
+set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
+set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
 set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
 
 set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
-set(ADD_LINUX_FILES False)
+set(EIVE_ADD_LINUX_FILES False)
 
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.
@@ -87,11 +93,11 @@ pre_source_hw_os_config()
 
 if(TGT_BSP)
     if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
-        OR TGT_BSP MATCHES "arm/beagleboneblack"
+        OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse"
     )
         set(FSFW_CONFIG_PATH "linux/fsfwconfig")
         if(NOT BUILD_Q7S_SIMPLE_MODE)
-            set(ADD_LINUX_FILES TRUE)
+            set(EIVE_ADD_LINUX_FILES TRUE)
             set(ADD_CSP_LIB TRUE)
             set(FSFW_HAL_ADD_LINUX ON)
         endif()
@@ -103,6 +109,12 @@ if(TGT_BSP)
         set(FSFW_HAL_ADD_RASPBERRY_PI ON)
     endif()
 
+    if(TGT_BSP MATCHES "arm/egse")
+        # Used by configure file
+        set(EGSE ON)
+        set(FSFW_HAL_LINUX_ADD_LIBGPIOD OFF)
+    endif()
+    
     if(TGT_BSP MATCHES "arm/beagleboneblack")
         # Used by configure file
         set(BEAGLEBONEBLACK ON)
@@ -117,17 +129,19 @@ else()
     set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
 endif()
 
+
 # Configuration files
-if(NOT EIVE_BUILD_WATCHDOG)
 configure_file(${COMMON_CONFIG_PATH}/commonConfig.h.in commonConfig.h)
 configure_file(${FSFW_CONFIG_PATH}/FSFWConfig.h.in FSFWConfig.h)
 configure_file(${FSFW_CONFIG_PATH}/OBSWConfig.h.in OBSWConfig.h)
 if(TGT_BSP MATCHES "arm/q7s")
     configure_file(${BSP_PATH}/boardconfig/q7sConfig.h.in q7sConfig.h)
-    elseif(TGT_BSP MATCHES "arm/raspberrypi")
+elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")
     configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
 endif()
-endif()
+
+
+
 configure_file(${WATCHDOG_PATH}/watchdogConf.h.in watchdogConf.h)
 
 # Set common config path for FSFW
@@ -136,120 +150,30 @@ set(FSFW_ADDITIONAL_INC_PATHS
     ${CMAKE_CURRENT_BINARY_DIR}
 )
 
+# Check whether the user has already installed Catch2 first
+find_package(Catch2 3)
+
 ################################################################################
 # Executable and Sources
 ################################################################################
 
-# Add executable
-add_executable(${TARGET_NAME})
-
-if(ADD_ETL_LIB)
-    add_subdirectory(${ETL_LIB_PATH})
-endif()
-
-if(ADD_JSON_LIB)
-    add_subdirectory(${LIB_JSON_PATH})
-endif()
-
-if(NOT EIVE_BUILD_WATCHDOG)
-    if(ADD_LINUX_FILES)
-        add_subdirectory(${LINUX_PATH})
-    endif()
-    add_subdirectory(${BSP_PATH})
-    add_subdirectory(${COMMON_PATH})
-    if(ADD_CSP_LIB)
-        add_subdirectory(${CSP_LIB_PATH})
-    endif()
-endif()
-
-if((NOT BUILD_Q7S_SIMPLE_MODE) AND (NOT EIVE_BUILD_WATCHDOG))
-    add_subdirectory(${LWGPS_LIB_PATH})
-    add_subdirectory(${FSFW_PATH})
-    add_subdirectory(${MISSION_PATH})
-    add_subdirectory(${TEST_PATH})
-    add_subdirectory(${ARCSEC_LIB_PATH})
-endif()
-
-if(EIVE_BUILD_WATCHDOG)
-    add_subdirectory(${WATCHDOG_PATH})
-endif()
-
-################################################################################
-# Post-Sources preparation
-################################################################################
-
-set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux)
-
-if((NOT BUILD_Q7S_SIMPLE_MODE) AND (NOT EIVE_BUILD_WATCHDOG))
-    # Add libraries for all sources.
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_FSFW_NAME}
-        ${LIB_OS_NAME}
-        ${LIB_LWGPS_NAME}
-    )
-
-    if(TGT_BSP MATCHES "arm/q7s")
-        target_link_libraries(${TARGET_NAME} PRIVATE
-            ${LIB_ARCSEC}
-        )
-    endif()
-endif()
-
-if(NOT EIVE_BUILD_WATCHDOG)
-    if(ADD_CSP_LIB)
-        target_link_libraries(${TARGET_NAME} PRIVATE
-            ${LIB_CSP_NAME}
-        )
-    endif()
-endif()
-
-if(ADD_ETL_LIB)
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_ETL_NAME}
-    )
-endif()
-
-if(ADD_JSON_LIB)
-    target_link_libraries(${TARGET_NAME} PRIVATE
-        ${LIB_JSON_NAME}
-    )
-endif()
-
-target_link_libraries(${TARGET_NAME} PRIVATE
-    ${LIB_CXX_FS}
-)
-
-# Add include paths for all sources.
-target_include_directories(${TARGET_NAME} PRIVATE
-	${CMAKE_CURRENT_SOURCE_DIR}
-	${FSFW_CONFIG_PATH}
-	${CMAKE_CURRENT_BINARY_DIR}
-	${ARCSEC_LIB_PATH}
-)	
-
-if(TGT_BSP MATCHES "arm/q7s")
-    target_include_directories(${TARGET_NAME} PRIVATE
-        ${ARCSEC_LIB_PATH}
-    )
-endif()
-
+#global compiler options need to be set before adding executables
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-	set(WARNING_FLAGS
-		-Wall
-		-Wextra
-		-Wimplicit-fallthrough=1
-		-Wno-unused-parameter
-		-Wno-psabi
+	add_compile_options(
+		"-Wall"
+		"-Wextra"
+		"-Wimplicit-fallthrough=1"
+		"-Wno-unused-parameter"
+		"-Wno-psabi"
 	)
-	
 	# Remove unused sections.
-	target_compile_options(${TARGET_NAME} PRIVATE
+	add_compile_options(
 		"-ffunction-sections"
 		"-fdata-sections"
 	)
 
 	# Removed unused sections.
-	target_link_options(${TARGET_NAME} PRIVATE
+	add_link_options(
 		"-Wl,--gc-sections"
 	)
 	
@@ -257,15 +181,162 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 	set(COMPILER_FLAGS "/permissive-")
 endif()
 
+# 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-preview4
+    )
+
+    FetchContent_MakeAvailable(Catch2)
+    #fixes regression -preview4, to be confirmed in later releases
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+    set_target_properties(Catch2 PROPERTIES EXCLUDE_FROM_ALL "true")
+    set_target_properties(Catch2WithMain PROPERTIES EXCLUDE_FROM_ALL "true")
+endif()
+
+
+
+add_library(${LIB_EIVE_MISSION})
+
+
+# Add main executable
+add_executable(${OBSW_NAME})
+if(EIVE_CREATE_UNIQUE_OBSW_BIN)
+    set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME}-$ENV{USERNAME})
+else()
+    set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})
+endif()
+set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
+
+#watchdog
+add_executable(${WATCHDOG_NAME} EXCLUDE_FROM_ALL)
+add_subdirectory(${WATCHDOG_PATH}) 
+target_link_libraries(${WATCHDOG_NAME} PUBLIC
+    ${LIB_CXX_FS}
+)
+target_include_directories(${WATCHDOG_NAME} PUBLIC
+    ${CMAKE_BINARY_DIR}
+)
+
+#unittests
+add_executable(${UNITTEST_NAME} EXCLUDE_FROM_ALL)
+
+
+
+if(EIVE_ADD_ETL_LIB)
+    add_subdirectory(${LIB_ETL_PATH})
+endif()
+
+if(EIVE_ADD_JSON_LIB)
+    add_subdirectory(${LIB_JSON_PATH})
+endif()
+
+
+ 
+if(EIVE_ADD_LINUX_FILES)
+    add_subdirectory(${LIB_ARCSEC_PATH})
+    add_subdirectory(${LINUX_PATH})
+endif()
+add_subdirectory(${BSP_PATH})
+if(ADD_CSP_LIB)
+    add_subdirectory(${LIB_CSP_PATH})
+endif()
+
+
+add_subdirectory(${COMMON_PATH})
+
+
+
+add_subdirectory(${LIB_LWGPS_PATH})
+add_subdirectory(${FSFW_PATH})
+add_subdirectory(${LIB_EIVE_MISSION_PATH})
+add_subdirectory(${TEST_PATH})
+
+
+add_subdirectory(${UNITTEST_PATH})
+
+
+################################################################################
+# Post-Sources preparation
+################################################################################
+
+
+
+# Add libraries
+target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
+    ${LIB_FSFW_NAME}
+    ${LIB_LWGPS_NAME}
+    ${LIB_OS_NAME}
+)
+
+target_link_libraries(${OBSW_NAME} PRIVATE
+    ${LIB_EIVE_MISSION}
+)
+
+if(TGT_BSP MATCHES "arm/q7s")
+    target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
+        ${LIB_ARCSEC}
+        ${LIB_GPS}
+    )
+endif()
+
+target_link_libraries(${UNITTEST_NAME} PRIVATE
+    Catch2
+    ${LIB_EIVE_MISSION}
+)
+
+if(TGT_BSP MATCHES "arm/egse")
+    target_link_libraries(${OBSW_NAME} PRIVATE
+	    ${LIB_ARCSEC}
+	)
+endif()
+
+if(ADD_CSP_LIB)
+    target_link_libraries(${OBSW_NAME} PRIVATE
+        ${LIB_CSP_NAME}
+    )
+endif()
+
+
+if(EIVE_ADD_ETL_LIB)
+    target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
+        ${LIB_ETL_NAME}
+    )
+endif()
+
+if(EIVE_ADD_JSON_LIB)
+    target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
+        ${LIB_JSON_NAME}
+    )
+endif()
+
+target_link_libraries(${LIB_EIVE_MISSION} PUBLIC
+    ${LIB_CXX_FS}
+)
+
+# Add include paths for all sources.
+target_include_directories(${LIB_EIVE_MISSION} PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${FSFW_CONFIG_PATH}
+	${CMAKE_CURRENT_BINARY_DIR}
+	${LIB_ARCSEC_PATH}
+)
+
+if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/egse")
+    target_include_directories(${LIB_EIVE_MISSION} PUBLIC
+        ${ARCSEC_LIB_PATH}
+    )
+endif()
+
 if(CMAKE_VERBOSE)
 	message(STATUS "Warning flags: ${WARNING_FLAGS}")
 endif()
 
 
-# Compile options for all sources.
-target_compile_options(${TARGET_NAME} PRIVATE
-	${WARNING_FLAGS}
-)
 
 if(${CMAKE_CROSSCOMPILING})
 	include (${CMAKE_SCRIPT_PATH}/HardwareOsPostConfig.cmake)
@@ -297,11 +368,12 @@ string(CONCAT POST_BUILD_COMMENT
 )
 
 add_custom_command(
-   TARGET ${TARGET_NAME}
+   TARGET ${OBSW_NAME}
    POST_BUILD
-   COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
+   COMMAND ${CMAKE_SIZE} ${OBSW_BIN_NAME}${FILE_SUFFIX}
    COMMENT ${POST_BUILD_COMMENT}
 )
 
+
 include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()

Justfile

@@ -0,0 +1,12 @@
+python_script := './cmake/scripts/cmake-build-cfg.py'
+
+default: q7s-debug-make
+
+q7s-debug-make:
+	{{python_script}} -o linux -g make -b debug -t "arm/q7s" -l build-Debug-Q7S
+
+q7s-release-make:
+	{{python_script}} -o linux -g make -b release -t "arm/q7s" -l build-Release-Q7S
+
+q7s-debug-ninja:
+	{{python_script}} -o linux -g ninja -b debug -t "arm/q7s" -l build-Debug-Q7S

README.md

@@ -11,13 +11,18 @@
 4. [Useful and Common Host Commands](#host-commands)
 5. [Setting up Prerequisites](#set-up-prereq)
 6. [Remote Debugging](#remote-debugging)
-7. [Direct Debugging](#direct-debugging)
-8. [Transfering Files to the Q7S](#file-transfer)
-9. [Q7S OBC](#q7s)
-10. [Static Code Analysis](#static-code-analysis)
-11. [Eclipse](#eclipse)
-12. [Running the OBSW on a Raspberry Pi](#rpi)
-13. [FSFW](#fsfw)
+6. [Remote Reset](#remote-reset)
+8. [TMTC testing](#tmtc-testing)
+9. [Direct Debugging](#direct-debugging)
+10. [Transfering Files to the Q7S](#file-transfer)
+11. [Q7S OBC](#q7s)
+12. [Static Code Analysis](#static-code-analysis)
+13. [Eclipse](#eclipse)
+14. [Running the OBSW on a Raspberry Pi](#rpi)
+15. [Running OBSW on EGSE](#egse)
+16. [Manually preparing sysroots to compile gpsd](#gpsd)
+17. [FSFW](#fsfw)
+18. [Coding Style](#coding-style)
 
 # <a id="general"></a> General information
 
@@ -35,7 +40,7 @@ Target systems:
      relevant pages. The most recent datasheet can be found 
      [here](https://trac2.xiphos.ca/manual/wiki/Q7RevB/UserManual).
    * Linux OS built with Yocto 2.5
-   * Linux Kernel https://github.com/XiphosSystemsCorp/linux-xlnx.git . EIVE version can be found
+   * [Linux Kernel](https://github.com/XiphosSystemsCorp/linux-xlnx.git) . EIVE version can be found
      [here](https://github.com/spacefisch/linux-xlnx) . Pre-compiled files can be
      found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/q7s-linux-components&fileid=777299).
    * Q7S base project can be found [here](https://egit.irs.uni-stuttgart.de/eive/q7s-base)
@@ -102,7 +107,7 @@ When using Windows, run theses steps in MSYS2.
 
    ```sh
    mkdir build-Debug-Q7S && cd build-Debug-Q7S
-   cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug -DOS_FSFW=linux ..
+   cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..
    cmake --build . -j
    ```
 
@@ -117,8 +122,7 @@ When using Windows, run theses steps in MSYS2.
    This will invoke a Python script which in turn invokes CMake with the correct
    arguments to configure CMake for Q7S cross-compilation.
    
-   You can build the hosted variant of the OBSW by replacing `-DOS_FSFW=linux` with 
-   `-DOS_FSFW=host`. There are also different values for `-DTGT_BSP` to build for the Raspberry Pi
+   There are also different values for `-DTGT_BSP` to build for the Raspberry Pi
    or the Beagle Bone Black: `arm/raspberrypi` and `arm/beagleboneblack`.
    
 5. Build the software with
@@ -157,20 +161,47 @@ automatically.
 
 ### Q7S OBSW
 
+The EIVE OBSW is the default target if no target is specified.
+
 ```sh
 mkdir build-Debug-Q7S && cd build-Debug-Q7S
-cmake -DTGT_BSP=arm/q7s -DFSFW_OSAL=linux -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Debug ..
 cmake --build . -j
 ```
 
 ### Q7S Watchdog
 
+To build the EIVE watchdog, the corresponding target must be specified in the build command.
+The configure steps do not need to be repeated if the folder has already been configured.
+
 ```sh
-mkdir build-Debug-Q7S && cd build-Debug-Q7S
-cmake -DTGT_BSP=arm/q7s -DFSFW_OSAL=linux -DEIVE_BUILD_WATCHDOG=ON -DCMAKE_BUILD_TYPE=Debug ..
+mkdir build-Debug-Watchdog && cd build-Debug-Watchdog
+cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Debug ..
+cmake --build . --target eive-watchdog -j
+```
+
+### Hosted
+
+You can also use the FSFW OSAL `host` to build on Windows or for generic OSes.
+Note: Currently this is not supported.
+
+```sh
+mkdir build-Debug-Host && cd build-Debug-Host
+cmake -DFSFW_OSAL=host -DCMAKE_BUILD_TYPE=Debug ..
 cmake --build . -j
 ```
 
+### Unittests
+
+To build the unittests, the corresponding target must be specified in the build command.
+The configure steps do not need to be repeated if the folder has already been configured.
+
+```sh
+mkdir build-Debug-Unittest && cd build-Debug-Unittest
+cmake ..
+cmake --build . --target eive-unittests -j
+```
+
 ## Connect to EIVE flatsat
 
 ### DNS
@@ -411,12 +442,24 @@ Beagle Bone Black for download here
 Download it and unzip it somewhere in the Xilinx installation folder.
 You can use the following command if `wget` can be used or for CI/CD:
 
-```
-wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/agnJGYeRf6fw2ci/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+```sh
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
 ```
 
 Then, create a new environmental variables `Q7S_SYSROOT` and set it to the local system root path.
 
+### Updating system root for CI
+
+If the system root is updated, it needs to be manually updated on the buggy file server.
+If access on `buggy.irs.uni-stuttgart.de` is possible with `ssh` and the rootfs in the cloud
+[was updated](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/rootfs&fileid=831849)
+as well, you can update the rootfs like this:
+
+```sh
+cd /var/www/eive/tools
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+```
+
 ## Setting up UNIX environment for real-time functionalities
 
 Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities 
@@ -514,10 +557,10 @@ ssh root@192.168.133.10
 ```
 
 If this has not been done yet, you can access the serial
-console of the Q7S like this to set it
+console of the Q7S like this
 
 ```sh
-picocom -b 115200 /dev/ttyUSB0
+picocom -b 115200 /dev/q7sSerial
 ```
 
 The flatsat has the aliases and shell scripts `q7s_ssh` and `q7s_serial` for this task as well.
@@ -554,6 +597,63 @@ alias or shell script to do this quickly.
 Note: When now setting up a debug session in the Xilinx SDK or Eclipse, the host must be set 
 to localhost instead of the IP address of the Q7S.
 
+# <a id="remote-reset"></a> Remote Reset
+1. Launch xilinx hardware server on flatsat with alias
+````
+launch-hwserver-xilinx
+````
+2. On host PC start xsc
+3. In xsct console type the follwing command to connect to the hardware server (replace </flatsat-pc-ip-address/> with the IP address of the flatsat PC. Can be found out with ifconfig)
+````
+connect -url tcp:</flatsat-pc-ip-address/>:3121
+````
+4. The following command will list all available devices
+````
+targets
+````
+5. Connect to the APU of the Q7S
+````
+target </APU-number/>
+````
+6. Perform reset
+````
+rst
+````
+
+# <a id="tmtc-testing"></a> TMTC testing
+
+The OBSW supports sending PUS TM packets via TCP or the PDEC IP Core which transmits the data as
+CADU frames. To make the CADU frames receivabel by the
+[TMTC porgram](https://egit.irs.uni-stuttgart.de/eive/eive-tmtc), a python script is running as
+`systemd` service named `tmtc_bridge` on the flatsat PC which forwards TCP commands to the TCP
+server of the OBC and reads CADU frames from a serial interface.
+
+You can check whether the service is running the following command on the flatsat PC
+
+```sh
+systemctl status tmtc_bridge
+```
+
+The PUS packets transported with the CADU frames are extracted
+and forwared to the TMTC program's TCP client. The code of the TMTC bridge can be found
+[here](https://egit.irs.uni-stuttgart.de/eive/tmtc-bridge). To connect the TMTC program to the
+TMTC-bridge a port forwarding from a host must be set up with the following command:
+
+```sh
+ssh -L 1537:127.0.0.1:7100 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 -t bash
+```
+
+You can print the output of the `systemd` service with
+
+```sh
+journalctl -u tmtc_bridge
+```
+
+This can be helpful to determine whether any TCs arrive or TMs are coming back.
+
+Note: The encoding of the TM packets and conversion of CADU frames takes some time.
+Thus the replies are received with a larger delay compared to a direct TCP connection.
+
 # <a id="direct-debugging"></a> Direct Debugging
 
 1. Assign static IP address to Q7S
@@ -966,26 +1066,7 @@ cat file.bin | hexdump -v -n X
 
 ## Preparation of a fresh rootfs and SD card
 
-This section summarizes important changes between a fresh rootfs and the current
-EIVE implementation
-
-### rootfs
-
-- Mount point `/mnt/sd0` created for SD card 0. Created with `mkdir`
-- Mount point `/mnt/sd1` created for SD card 1. Created with `mkdir`
-- Folder `scripts` in `/home/root` folder.
-- `scripts` folder currently contains a few shell helper scripts
-- Folder `profile.d` in `/etc` folder which contains the `path-set.sh` script
-  which is sourced at software startup
-- Library `libwire.so` in `/usr/lib` folder
-
-### SD Cards
-
-- Folder `bin` for binaries, for example the OBSW
-- Folder `misc` for miscellaneous files. Contains `ls` for directory listings
-- Folder `tc` for telecommands
-- Folder `tm` for telemetry
-- Folder `xdi` for XDI components (e.g. for firmware or device tree updates)
+See [q7s-package repository README](https://egit.irs.uni-stuttgart.de/eive/q7s-package)
 
 # <a id="static-code-analysis"></a> Running cppcheck on the Software
 
@@ -1033,7 +1114,7 @@ The [TCF agent](https://wiki.eclipse.org/TCF) can be used to perform remote debu
 1. Install the TCF agent plugin in Eclipse from
    the [releases](https://www.eclipse.org/tcf/downloads.php). Go to
    Help &rarr; Install New Software and use the download page, for
-   example https://download.eclipse.org/tools/tcf/releases/1.6/1.6.2/ to search for the plugin and install it.
+   example https://download.eclipse.org/tools/tcf/releases/1.7/1.7.0/ to search for the plugin and install it. You can find the newest version [here](https://www.eclipse.org/tcf/downloads.php)
 
 2. Go to Window &rarr; Perspective &rarr; Open Perspective and open the **Target Explorer Perspective**. 
    Here, the Q7S should show up if the local port forwarding was set up as explained previously.
@@ -1072,6 +1153,38 @@ sudo apt-get install gpiod libgpiod-dev
 
 to install the required GPIO libraries before cloning the system root folder.
 
+# <a id="egse"></a> Running OBSW on EGSE
+The EGSE is a test system from arcsec build arround a raspberry pi 4 to test the star tracker. The IP address of the EGSE (raspberry pi) is 192.168.18.31. An ssh session can be opened with
+````
+ssh pi@192.168.18.31
+````
+Password: raspberry
+
+To run the obsw perform the following steps:
+1. Build the cmake EGSE Configuration 
+   * the sysroots for the EGSE can be found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/egse&fileid=1190471)
+   * toolchain for linux host can be downloaded from [here](https://github.com/Pro/raspi-toolchain)
+   * toolchain for windows host from [here](https://gnutoolchains.com/raspberry/) (the raspios-buster-armhf toolchain is the right one for the EGSE)
+2. Disable the ser2net systemd service on the EGSE
+````sh
+$ sudo systemctl stop ser2net.service
+````
+3. Power on the star tracker by running
+````sh
+$ ~/powerctrl/enable0.sh`
+````
+4. Run portforwarding script for tmtc tcp connection and tcf agent on host PC
+````sh
+$ ./scripts/egse-port.sh
+````
+5. The star tracker can be powered off by running
+````sh
+$ ~/powerctrl/disable0.sh
+````
+
+# <a id="gpsd"></a> Manually preparing sysroots to compile gpsd
+Copy all header files from [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/gpsd&fileid=1189985) to the /usr/include directory and all static libraries to /usr/lib.
+
 # <a id="fsfw"></a> Flight Software Framework (FSFW)
 
 An EIVE fork of the FSFW is submodules into this repository.
@@ -1091,3 +1204,15 @@ git merge upstream/master
 
 Alternatively, changes from other upstreams (forks) and branches can be merged like that
 in the same way.
+
+# <a id="coding-style"></a> Coding Style
+* the formatting is based on the clang-format tools
+## Setting up eclipse auto-fromatter with clang-format
+1. Help &rarr; Install New Software &rarr; Add
+2. In location insert the link http://www.cppstyle.com/luna
+3. The software package CppStyle should now be available for installation
+4. On windows download the clang-formatting tools from https://llvm.org/builds/. On linux clang-format can be installed with the package manager.
+5. Navigate to Preferences &rarr; C/C++ &rarr; CppStyle 
+6. Insert the path to the clang-format executable
+7. Under C/C++ &rarr; Code Style &rarr; Formatter, change the formatter to CppStyle (clang-format)
+8. Code can now be formatted with the clang tool by using the key combination Ctrl + Shift + f

automation/Dockerfile

@@ -2,7 +2,9 @@ FROM ubuntu:focal
 
 RUN apt-get update
 RUN apt-get --yes upgrade
-RUN apt-get --yes install cmake libgpiod-dev xz-utils nano curl
+#tzdata is a dependency, won't install otherwise
+ARG DEBIAN_FRONTEND=noninteractive
+RUN apt-get --yes install cmake libgpiod-dev xz-utils nano curl git gcc g++ lcov valgrind libgps-dev
 
 # Q7S root filesystem, required for cross-compilation.
 RUN mkdir -p /usr/rootfs; \
@@ -14,6 +16,5 @@ RUN mkdir -p /usr/tools; \
 curl https://buggy.irs.uni-stuttgart.de/eive/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.gz \
     | tar -xz -C /usr/tools
 
-
 ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
 ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"

automation/Jenkinsfile

@@ -1,48 +1,36 @@
 pipeline {
-    agent any
+    environment {
+        BUILDDIR_Q7 = 'build_q7'
+        BUILDDIR_LINUX = 'build_linux'
+    }
+    agent {
+        docker {
+            image 'eive-obsw-ci:d2'
+            args '--sysctl fs.mqueue.msg_max=100'
+        }
+    }
     stages {
-        stage('Build Container') {
-            when {
-                changeset "automation/Dockerfile-q7s"
-                branch 'develop'
-            }
-            steps {
-                sh 'docker build -t eive-fsw-build-q7s:gcc8 - < automation/Dockerfile-q7s'
-
-            }
-        }
         stage('Clean') {
-            when {
-                anyOf {
-                    changelog 'cleanCI'
-                    changeset '*.cmake'
-                    changeset 'CMakeLists.txt'
-                }
-            }
             steps {
-                sh 'rm -rf build-q7s-debug'
+                sh 'rm -rf $BUILDDIR_Q7'
+                sh 'rm -rf $BUILDDIR_LINUX'
             }
         }
         stage('Build Q7S') {
-            agent {
-                docker {
-                    image 'eive-fsw-build-q7s:gcc8'
-                    reuseNode true
-                }
-            }
             steps {
-                dir('build-q7s-debug') {
-                    sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug -DFSFW_OSAL=linux ..'
+                dir(BUILDDIR_Q7) {
+                    sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..'
                     sh 'cmake --build . -j'
                 }
             }
         }
-        stage('Deploy') {
-            when {
-                tag 'v*.*.*'
-            }
+        stage('Unittests') {
             steps {
-                sh 'echo Deploying'
+                dir(BUILDDIR_LINUX) {
+                    sh 'cmake ..'
+                    sh 'cmake --build . -t eive-unittest -j'
+                    sh './eive-unittest'
+                }
             }
         }
     }

bsp_egse/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PUBLIC
+	InitMission.cpp
+	main.cpp
+	ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)

bsp_egse/InitMission.cpp

@@ -0,0 +1,192 @@
+#include "InitMission.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Make sure the systemd service ser2net on the egse has been stopped "
+            << "(alias stop-ser2net)" << std::endl;
+  sif::info << "Make sure the power lines of the star tracker have been enabled "
+            << "(alias enable-startracker)" << std::endl;
+  sif::info << "Building global objects.." << std::endl;
+  /* Instantiate global object manager and also create all objects */
+  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component TMTC Polling failed" << std::endl;
+  }
+
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+  std::vector<PeriodicTaskIF*> pstTasks;
+  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
+      "STAR_TRACKER_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = pst::pstUart(pst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  }
+  pstTasks.push_back(pst);
+
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+  }
+  pstTasks.push_back(strHelperTask);
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
+    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmtcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  taskStarter(pstTasks, "PST Tasks");
+  taskStarter(pusTasks, "PUS Tasks");
+
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+  }
+  taskVec.push_back(pusEvents);
+
+  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  taskVec.push_back(pusMedPrio);
+
+  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
+      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}

bsp_egse/InitMission.h

@@ -0,0 +1,21 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include <vector>
+
+#include "fsfw/tasks/Typedef.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
+namespace initmission {
+void initMission();
+void initTasks();
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+};  // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */

bsp_egse/ObjectFactory.cpp

@@ -0,0 +1,49 @@
+#include "ObjectFactory.h"
+
+#include <devConf.h>
+#include <fsfw_hal/linux/uart/UartComIF.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <mission/devices/GPSHyperionHandler.h>
+
+#include "OBSWConfig.h"
+#include "busConf.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/startracker/StarTrackerHandler.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/utility/TmFunnel.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+  UartCookie* starTrackerCookie =
+      new UartCookie(objects::STAR_TRACKER, egse::STAR_TRACKER_UART, UartModes::NON_CANONICAL,
+                     uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
+  new UartComIF(objects::UART_COM_IF);
+  starTrackerCookie->setNoFixedSizeReply();
+  StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
+  StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
+      objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, strHelper);
+  starTrackerHandler->setStartUpImmediately();
+}

bsp_egse/ObjectFactory.h

@@ -0,0 +1,8 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+void produce(void* args);
+};  // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_egse/boardconfig/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PRIVATE
+	print.c
+)
+
+target_include_directories(${OBSW_NAME} PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}
+)

bsp_egse/boardconfig/busConf.h

@@ -0,0 +1,8 @@
+#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+
+namespace egse {
+static constexpr char STAR_TRACKER_UART[] = "/dev/serial0";
+}
+
+#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */

bsp_egse/boardconfig/etl_profile.h

@@ -0,0 +1,38 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2019 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_CHECK_PUSH_POP
+
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0
+
+#endif

bsp_egse/boardconfig/gcov.h

@@ -0,0 +1,15 @@
+#ifndef LINUX_GCOV_H_
+#define LINUX_GCOV_H_
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+#ifdef GCOV
+extern "C" void __gcov_flush();
+#else
+void __gcov_flush() {
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
+}
+#endif
+
+#endif /* LINUX_GCOV_H_ */

bsp_egse/boardconfig/print.c

@@ -0,0 +1,10 @@
+#include <bsp_egse/boardconfig/print.h>
+#include <stdio.h>
+
+void printChar(const char* character, bool errStream) {
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
+}

bsp_egse/boardconfig/print.h

@@ -0,0 +1,8 @@
+#ifndef HOSTED_BOARDCONFIG_PRINT_H_
+#define HOSTED_BOARDCONFIG_PRINT_H_
+
+#include <stdbool.h>
+
+void printChar(const char* character, bool errStream);
+
+#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */

bsp_egse/boardconfig/rpiConfig.h.in

@@ -0,0 +1,6 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include <cstdint>
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */

bsp_egse/main.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/FSFWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+/**
+ * @brief 	    This is the main program entry point for the egse (raspberry pi 4)
+ * @return
+ */
+int main(void) {
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for EGSE from Arcsec"
+            << " --" << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
+            << "--" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+  initmission::initMission();
+
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
+}

bsp_hosted/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PUBLIC
+target_sources(${OBSW_NAME} PUBLIC
 	InitMission.cpp
 	main.cpp
 	ObjectFactory.cpp

bsp_hosted/InitMission.cpp

@@ -1,20 +1,19 @@
 #include "InitMission.h"
-#include "ObjectFactory.h"
 
 #include <OBSWConfig.h>
-
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
-
 #include <mission/utility/InitMission.h>
 
 #include <iostream>
 
+#include "ObjectFactory.h"
+
 #ifdef LINUX
 ServiceInterfaceStream sif::debug("DEBUG");
 ServiceInterfaceStream sif::info("INFO");
@@ -55,8 +54,7 @@ void initmission::initTasks() {
   /* TMTC Distribution */
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
       "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-    ReturnValue_t result = tmTcDistributor->addComponent(
-            objects::CCSDS_PACKET_DISTRIBUTOR);
+  ReturnValue_t result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "Object add component failed" << std::endl;
   }

bsp_hosted/InitMission.h

@@ -4,6 +4,6 @@
 namespace initmission {
 void initMission();
 void initTasks();
-};
+};  // namespace initmission
 
 #endif /* BSP_LINUX_INITMISSION_H_ */

bsp_hosted/ObjectFactory.cpp

@@ -1,14 +1,14 @@
 #include "ObjectFactory.h"
-#include "OBSWConfig.h"
+
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <mission/core/GenericFactory.h>
+#include <mission/utility/TmFunnel.h>
 #include <objects/systemObjectList.h>
 #include <tmtc/apid.h>
 #include <tmtc/pusIds.h>
 
-#include <fsfw/tmtcservices/CommandingServiceBase.h>
-#include <fsfw/tmtcservices/PusServiceBase.h>
-
-#include <mission/core/GenericFactory.h>
-#include <mission/utility/TmFunnel.h>
+#include "OBSWConfig.h"
 
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
 #include "fsfw/osal/common/UdpTcPollingTask.h"
@@ -20,7 +20,6 @@
 
 #include <fsfw/tmtcpacket/pus/tm.h>
 
-
 #if OBSW_ADD_TEST_CODE == 1
 #include <test/testtasks/TestTask.h>
 #endif
@@ -44,18 +43,5 @@ void ObjectFactory::produce(void* args){
   Factory::setStaticFrameworkObjectIds();
   ObjectFactory::produceGenericObjects();
 
-#if OBSW_USE_TMTC_TCP_BRIDGE == 0
-	sif::info << "Setting up UDP TMTC bridge with listener port " <<
-	        UdpTmTcBridge::DEFAULT_SERVER_PORT << std::endl;
-    new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#else
-    sif::info << "Setting up TCP TMTC bridge with listener port " <<
-            TcpTmTcServer::DEFAULT_SERVER_PORT << std::endl;
-    new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#endif
-
   new TestTask(objects::TEST_TASK);
-
 }

bsp_hosted/ObjectFactory.h

@@ -1,10 +1,9 @@
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_
 
-
 namespace ObjectFactory {
 void setStatics();
 void produce(void* args);
-};
+};  // namespace ObjectFactory
 
 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_hosted/boardconfig/CMakeLists.txt

@@ -1,8 +1,8 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	print.c
 )
 
-target_include_directories(${TARGET_NAME} PUBLIC
+target_include_directories(${OBSW_NAME} PUBLIC
 	${CMAKE_CURRENT_SOURCE_DIR}
 )
 

bsp_hosted/boardconfig/gcov.h

@@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
   sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif
 

bsp_hosted/boardconfig/print.c

@@ -9,7 +9,3 @@ void printChar(const char* character, bool errStream) {
   }
   putc(*character, stdout);
 }
-
-
-
-

bsp_hosted/comIF/ArduinoComIF.cpp

@@ -1,26 +1,25 @@
 #include "ArduinoComIF.h"
-#include "ArduinoCookie.h"
 
-#include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/globalfunctions/CRC.h>
+#include <fsfw/globalfunctions/DleEncoder.h>
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 
+#include "ArduinoCookie.h"
+
 // This only works on Linux
 #ifdef LINUX
-#include <termios.h>
 #include <fcntl.h>
+#include <termios.h>
 #include <unistd.h>
 #elif WIN32
-#include <windows.h>
 #include <strsafe.h>
+#include <windows.h>
 #endif
 
 #include <cstring>
 
-ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
-        const char *serialDevice):
-		rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES*10, true),
-		SystemObject(setObjectId) {
+ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF, const char *serialDevice)
+    : rxBuffer(MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES * 10, true), SystemObject(setObjectId) {
 #ifdef LINUX
   initialized = false;
   serialPort = ::open("/dev/ttyUSB0", O_RDWR);
@@ -66,7 +65,6 @@ ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
     sif::info << "Please enter the COM port (c to cancel): " << std::flush;
     std::string comPort;
     while (hCom == INVALID_HANDLE_VALUE) {
-
       std::getline(std::cin, comPort);
       if (comPort[0] == 'c') {
         break;
@@ -80,37 +78,29 @@ ArduinoComIF::ArduinoComIF(object_id_t setObjectId, bool promptComIF,
                          0,                             // Non Overlapped I/O
                          NULL);                         // Null for Comm Devices
 
-	        if (hCom == INVALID_HANDLE_VALUE)
-	        {
+      if (hCom == INVALID_HANDLE_VALUE) {
         if (GetLastError() == 2) {
           sif::error << "COM Port does not found!" << std::endl;
-	            }
-	            else {
+        } else {
           TCHAR err[128];
-	                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
-	                        GetLastError(),
-	                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-	                        err, sizeof(err), NULL);
+          FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
+                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err, sizeof(err), NULL);
           //  Handle the error.
-	                sif::info << "CreateFileA Error code: " << GetLastError()
-	                         << std::endl;
+          sif::info << "CreateFileA Error code: " << GetLastError() << std::endl;
           sif::error << err << std::flush;
         }
         sif::info << "Please enter a valid COM port: " << std::flush;
       }
     }
-
   }
 
-
   serialParams.DCBlength = sizeof(serialParams);
   if (baudRate == 9600) {
     serialParams.BaudRate = CBR_9600;
   }
   if (baudRate == 115200) {
     serialParams.BaudRate = CBR_115200;
-	}
-	else {
+  } else {
     serialParams.BaudRate = baudRate;
   }
 
@@ -143,29 +133,22 @@ ReturnValue_t ArduinoComIF::initializeInterface(CookieIF * cookie) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data,
-		size_t len) {
+ReturnValue_t ArduinoComIF::sendMessage(CookieIF *cookie, const uint8_t *data, size_t len) {
   ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
   if (arduinoCookie == nullptr) {
     return INVALID_COOKIE_TYPE;
   }
 
-	return sendMessage(arduinoCookie->command, arduinoCookie->address, data,
-			len);
+  return sendMessage(arduinoCookie->command, arduinoCookie->address, data, len);
 }
 
-ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) {
+ReturnValue_t ArduinoComIF::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
   return RETURN_OK;
 }
 
-ReturnValue_t ArduinoComIF::requestReceiveMessage(CookieIF *cookie,
-        size_t requestLen) {
-	return RETURN_OK;
-}
-
-ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie,
-		uint8_t **buffer, size_t *size) {
-
+ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
   handleSerialPortRx();
 
   ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie *>(cookie);
@@ -178,8 +161,8 @@ ReturnValue_t ArduinoComIF::readReceivedMessage(CookieIF *cookie,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
-		uint8_t address, const uint8_t *data, size_t dataLen) {
+ReturnValue_t ArduinoComIF::sendMessage(uint8_t command, uint8_t address, const uint8_t *data,
+                                        size_t dataLen) {
   if (dataLen > UINT16_MAX) {
     return TOO_MUCH_DATA;
   }
@@ -193,16 +176,15 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
   size_t remainingLen = sizeof(sendBuffer) - 1;
   size_t encodedLen = 0;
 
-	ReturnValue_t result = DleEncoder::encode(&command, 1, currentPosition,
-			remainingLen, &encodedLen, false);
+  ReturnValue_t result =
+      DleEncoder::encode(&command, 1, currentPosition, remainingLen, &encodedLen, false);
   if (result != RETURN_OK) {
     return result;
   }
   currentPosition += encodedLen;
   remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen
 
-	result = DleEncoder::encode(&address, 1, currentPosition, remainingLen,
-			&encodedLen, false);
+  result = DleEncoder::encode(&address, 1, currentPosition, remainingLen, &encodedLen, false);
   if (result != RETURN_OK) {
     return result;
   }
@@ -215,8 +197,8 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
   temporaryBuffer[0] = dataLen >> 8;  // we checked dataLen above
   temporaryBuffer[1] = dataLen;
 
-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
+  result =
+      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
   if (result != RETURN_OK) {
     return result;
   }
@@ -224,8 +206,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
   remainingLen -= encodedLen;  // DleEncoder will never return encodedLen > remainingLen
 
   // encoding the actual data
-	result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen,
-			&encodedLen, false);
+  result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen, &encodedLen, false);
   if (result != RETURN_OK) {
     return result;
   }
@@ -241,8 +222,8 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
   temporaryBuffer[0] = crc >> 8;
   temporaryBuffer[1] = crc;
 
-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
+  result =
+      DleEncoder::encode(temporaryBuffer, 2, currentPosition, remainingLen, &encodedLen, false);
   if (result != RETURN_OK) {
     return result;
   }
@@ -279,8 +260,7 @@ void ArduinoComIF::handleSerialPortRx() {
 
   uint8_t dataFromSerial[availableSpace];
 
-	ssize_t bytesRead = read(serialPort, dataFromSerial,
-			sizeof(dataFromSerial));
+  ssize_t bytesRead = read(serialPort, dataFromSerial, sizeof(dataFromSerial));
 
   if (bytesRead < 0) {
     return;
@@ -292,13 +272,12 @@ void ArduinoComIF::handleSerialPortRx() {
 
   uint32_t dataLenReceivedSoFar = 0;
 
-	rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true,
-			&dataLenReceivedSoFar);
+  rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true, &dataLenReceivedSoFar);
 
   // look for STX
   size_t firstSTXinRawData = 0;
-	while ((firstSTXinRawData < dataLenReceivedSoFar)
-			&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
+  while ((firstSTXinRawData < dataLenReceivedSoFar) &&
+         (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
     firstSTXinRawData++;
   }
 
@@ -313,10 +292,9 @@ void ArduinoComIF::handleSerialPortRx() {
 
   size_t readSize = 0;
 
-	ReturnValue_t result = DleEncoder::decode(
-			dataReceivedSoFar + firstSTXinRawData,
-			dataLenReceivedSoFar - firstSTXinRawData, &readSize, packet,
-			sizeof(packet), &packetLen);
+  ReturnValue_t result = DleEncoder::decode(dataReceivedSoFar + firstSTXinRawData,
+                                            dataLenReceivedSoFar - firstSTXinRawData, &readSize,
+                                            packet, sizeof(packet), &packetLen);
 
   size_t toDelete = firstSTXinRawData;
   if (result == HasReturnvaluesIF::RETURN_OK) {
@@ -333,9 +311,7 @@ void ArduinoComIF::handleSerialPortRx() {
 #endif
 }
 
-void ArduinoComIF::setBaudrate(uint32_t baudRate) {
-    this->baudRate = baudRate;
-}
+void ArduinoComIF::setBaudrate(uint32_t baudRate) { this->baudRate = baudRate; }
 
 void ArduinoComIF::handlePacket(uint8_t *packet, size_t packetLen) {
   uint16_t crc = CRC::crc16ccitt(packet, packetLen);
@@ -368,8 +344,7 @@ void ArduinoComIF::handlePacket(uint8_t *packet, size_t packetLen) {
       }
       std::memcpy(cookie.replyBuffer.data(), packet + 4, packetLen - 6);
       cookie.receivedDataLen = packetLen - 6;
-	}
-		break;
+    } break;
     default:
       return;
   }

bsp_hosted/comIF/ArduinoComIF.h

@@ -4,8 +4,8 @@
 #include <fsfw/container/FixedMap.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
 
 #include <cstdint>
 #include <map>
@@ -17,8 +17,7 @@
 // Forward declaration, so users don't peek
 class ArduinoCookie;
 
-class ArduinoComIF: public SystemObject,
-		public DeviceCommunicationIF {
+class ArduinoComIF : public SystemObject, public DeviceCommunicationIF {
  public:
   static const uint8_t MAX_NUMBER_OF_SPI_DEVICES = 8;
   static const uint8_t MAX_PACKET_SIZE = 64;
@@ -34,13 +33,12 @@ public:
 
   /** DeviceCommunicationIF overrides */
   virtual ReturnValue_t initializeInterface(CookieIF *cookie) override;
-    virtual ReturnValue_t sendMessage(CookieIF *cookie,
-            const uint8_t * sendData, size_t sendLen) override;
+  virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                    size_t sendLen) override;
   virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
-    virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
-            size_t requestLen) override;
-    virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
-            uint8_t **buffer, size_t *size) override;
+  virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                            size_t *size) override;
 
  private:
 #ifdef LINUX
@@ -59,8 +57,7 @@ private:
 
   SimpleRingBuffer rxBuffer;
 
-	ReturnValue_t sendMessage(uint8_t command, uint8_t address,
-			const uint8_t *data, size_t dataLen);
+  ReturnValue_t sendMessage(uint8_t command, uint8_t address, const uint8_t *data, size_t dataLen);
   void handleSerialPortRx();
 
   void handlePacket(uint8_t *packet, size_t packetLen);

bsp_hosted/comIF/ArduinoCookie.cpp

@@ -1,8 +1,8 @@
 #include <bsp_hosted/comIF/ArduinoCookie.h>
 
-ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address,
-		const size_t maxReplySize) :
-		protocol(protocol), command(protocol), address(address),
-		maxReplySize(maxReplySize), replyBuffer(maxReplySize) {
-}
-
+ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize)
+    : protocol(protocol),
+      command(protocol),
+      address(address),
+      maxReplySize(maxReplySize),
+      replyBuffer(maxReplySize) {}

bsp_hosted/comIF/ArduinoCookie.h

@@ -2,18 +2,14 @@
 #define MISSION_ARDUINO_ARDUINOCOOKIE_H_
 
 #include <fsfw/devicehandlers/CookieIF.h>
+
 #include <vector>
 
 class ArduinoCookie : public CookieIF {
  public:
-	enum Protocol_t: uint8_t {
-		INVALID,
-		SPI,
-		I2C
-	};
+  enum Protocol_t : uint8_t { INVALID, SPI, I2C };
 
-	ArduinoCookie(Protocol_t protocol, uint8_t address,
-	        const size_t maxReplySize);
+  ArduinoCookie(Protocol_t protocol, uint8_t address, const size_t maxReplySize);
 
   Protocol_t protocol;
   uint8_t command;
@@ -21,7 +17,6 @@ public:
   std::vector<uint8_t> replyBuffer;
   size_t receivedDataLen = 0;
   size_t maxReplySize;
-
 };
 
 #endif /* MISSION_ARDUINO_ARDUINOCOOKIE_H_ */

bsp_hosted/fsfwconfig/CMakeLists.txt

@@ -1,21 +1,27 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	ipc/MissionMessageTypes.cpp
 )
 
-target_include_directories(${TARGET_NAME} PUBLIC
+target_include_directories(${OBSW_NAME} PUBLIC
 	${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 # If a special translation file for object IDs exists, compile it.
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
-    target_sources(${TARGET_NAME} PRIVATE
+    target_sources(${OBSW_NAME} PRIVATE
+        objects/translateObjects.cpp
+    )
+    target_sources(${UNITTEST_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(${TARGET_NAME} PRIVATE
+    target_sources(${OBSW_NAME} PRIVATE
+        events/translateEvents.cpp
+    )
+    target_sources(${UNITTEST_NAME} PRIVATE
         events/translateEvents.cpp
     )
 endif()

bsp_hosted/fsfwconfig/OBSWConfig.h.in

@@ -14,6 +14,12 @@
 debugging. */
 #define OBSW_VEBOSE_LEVEL       1
 
+#define OBSW_USE_CCSDS_IP_CORE                      0
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             0
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           0
+
 #ifdef __cplusplus
 
 #include "objects/systemObjectList.h"

bsp_hosted/fsfwconfig/devices/gpioIds.h

@@ -1,8 +1,6 @@
 #ifndef FSFWCONFIG_DEVICES_GPIOIDS_H_
 #define FSFWCONFIG_DEVICES_GPIOIDS_H_
 
-#include <linux/gpio/GpioIF.h>
-
 namespace gpioIds {
 enum gpioId_t {
   HEATER_0,
@@ -27,33 +25,33 @@ namespace gpioIds {
   TEST_ID_0,
   TEST_ID_1,
 
-		RTD_IC3,
-        RTD_IC4,
-        RTD_IC5,
-        RTD_IC6,
-        RTD_IC7,
-        RTD_IC8,
-        RTD_IC9,
-        RTD_IC10,
-        RTD_IC11,
-        RTD_IC12,
-        RTD_IC13,
-        RTD_IC14,
-        RTD_IC15,
-        RTD_IC16,
-        RTD_IC17,
-        RTD_IC18,
+  RTD_IC_3,
+  RTD_IC_4,
+  RTD_IC_5,
+  RTD_IC_6,
+  RTD_IC_7,
+  RTD_IC_8,
+  RTD_IC_9,
+  RTD_IC_10,
+  RTD_IC_11,
+  RTD_IC_12,
+  RTD_IC_13,
+  RTD_IC_14,
+  RTD_IC_15,
+  RTD_IC_16,
+  RTD_IC_17,
+  RTD_IC_18,
 
   SPI_MUX_BIT_1,
   SPI_MUX_BIT_2,
   SPI_MUX_BIT_3,
   SPI_MUX_BIT_4,
   SPI_MUX_BIT_5,
-        SPI_MUX_BIT_6
+  SPI_MUX_BIT_6,
+
+  CS_RAD_SENSOR,
+  ENABLE_RADFET
 };
 }
 
-
-
-
 #endif /* FSFWCONFIG_DEVICES_GPIOIDS_H_ */

bsp_hosted/fsfwconfig/devices/powerSwitcherList.h

@@ -52,7 +52,6 @@ namespace pcduSwitches {
 static const uint8_t INIT_STATE_SOLAR_CELL_EXP = OFF;
 static const uint8_t INIT_STATE_PLOC = OFF;
 static const uint8_t INIT_STATE_ACS_BOARD_SIDE_A = OFF;
-}
-
+}  // namespace pcduSwitches
 
 #endif /* FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_ */

bsp_hosted/fsfwconfig/events/subsystemIdRanges.h

@@ -2,6 +2,7 @@
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 
 #include <common/config/commonSubsystemIds.h>
+
 #include <cstdint>
 
 /**
@@ -9,9 +10,7 @@
  * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)
  */
 namespace SUBSYSTEM_ID {
-enum: uint8_t {
-	SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END
-};
+enum : uint8_t { SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END };
 }
 
 #endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */

bsp_hosted/fsfwconfig/fsfwconfig.mk

@@ -1,7 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/cdatapool/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
-
-INCLUDES += $(CURRENTPATH)

bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.cpp

@@ -1,4 +1,5 @@
 #include "MissionMessageTypes.h"
+
 #include <fsfw/ipc/CommandMessage.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
@@ -7,5 +8,3 @@ void messagetypes::clearMissionMessage(CommandMessage* message) {
       break;
   }
 }
-
-

bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.h

@@ -17,6 +17,6 @@ enum MESSAGE_TYPE {
 };
 
 void clearMissionMessage(CommandMessage* message);
-}
+}  // namespace messagetypes
 
 #endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -1,9 +1,10 @@
 #ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
-#include <cstdint>
 #include <commonObjects.h>
 
+#include <cstdint>
+
 // The objects will be instantiated in the ID order
 namespace objects {
 enum sourceObjects : uint32_t {

bsp_hosted/fsfwconfig/returnvalues/classIds.h

@@ -1,9 +1,10 @@
 #ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
 #define CONFIG_RETURNVALUES_CLASSIDS_H_
 
-#include "commonClassIds.h"
 #include <fsfw/returnvalues/FwClassIds.h>
 
+#include "commonClassIds.h"
+
 /**
  * Source IDs starts at 73 for now
  * Framework IDs for ReturnValues run from 0 to 56
@@ -15,5 +16,4 @@ enum {
 };
 }
 
-
 #endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */

bsp_hosted/fsfwconfig/tmtc/apid.h

@@ -15,5 +15,4 @@ namespace apid {
 static const uint16_t EIVE_OBSW = 0x65;
 }
 
-
 #endif /* FSFWCONFIG_TMTC_APID_H_ */

bsp_hosted/main.cpp

@@ -1,10 +1,9 @@
+#include <iostream>
+
 #include "InitMission.h"
 #include "OBSWVersion.h"
-
 #include "fsfw/FSFWVersion.h"
 #include "fsfw/tasks/TaskFactory.h"
-
-#include <iostream>
 #ifdef WIN32
 static const char* COMPILE_PRINTOUT = "Windows";
 #elif LINUX
@@ -17,13 +16,12 @@ static const char* COMPILE_PRINTOUT = "unknown OS";
  * 			Linux and Windows.
  * @return
  */
-int main(void)
-{
+int main(void) {
   std::cout << "-- EIVE OBSW --" << std::endl;
   std::cout << "-- Compiled for " << COMPILE_PRINTOUT << " --" << std::endl;
-    std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION <<
-            "." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "." <<
-            FSFW_REVISION << "--"  << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "."
+            << FSFW_REVISION << "--" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
   initmission::initMission();
@@ -33,5 +31,3 @@ int main(void)
     TaskFactory::delayTask(5000);
   }
 }
-
-

bsp_linux_board/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PUBLIC
+target_sources(${OBSW_NAME} PUBLIC
 	InitMission.cpp
 	main.cpp
 	ObjectFactory.cpp

bsp_linux_board/InitMission.cpp

@@ -1,21 +1,21 @@
 #include "InitMission.h"
-#include "ObjectFactory.h"
 
-#include "objects/systemObjectList.h"
-#include "OBSWConfig.h"
-#include "pollingsequence/pollingSequenceFactory.h"
-
-#include <mission/utility/InitMission.h>
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
 #include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
 
 #include <iostream>
 
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
 ServiceInterfaceStream sif::debug("DEBUG");
 ServiceInterfaceStream sif::info("INFO");
 ServiceInterfaceStream sif::warning("WARNING");
@@ -47,7 +47,6 @@ void initmission::initTasks() {
   void (*missedDeadlineFunc)(void) = nullptr;
 #endif
 
-
   /* TMTC Distribution */
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
       "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
@@ -65,17 +64,17 @@ void initmission::initTasks() {
   }
 
   /* UDP bridge */
-    PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
-            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-    result = udpBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
   }
-    PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
-            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
-    result = udpPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "Add component UDP Polling failed" << std::endl;
+    sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
   /* PUS Services */
@@ -93,8 +92,7 @@ void initmission::initTasks() {
     for (const auto& task : taskVector) {
       if (task != nullptr) {
         task->startTask();
-            }
-            else {
+      } else {
         sif::error << "Task in vector " << name << " is invalid!" << std::endl;
       }
     }
@@ -102,8 +100,8 @@ void initmission::initTasks() {
 
   sif::info << "Starting tasks.." << std::endl;
   tmTcDistributor->startTask();
-    udpBridgeTask->startTask();
-    udpPollingTask->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
 
   taskStarter(pusTasks, "PUS Tasks");
 #if OBSW_ADD_TEST_CODE == 1
@@ -120,7 +118,8 @@ void initmission::initTasks() {
 }
 
 void initmission::createPusTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*>& taskVec) {
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
       "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
@@ -182,19 +181,18 @@ void initmission::createPusTasks(TaskFactory& factory,
   }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("INT_ERR_RPRT",
-                objects::INTERNAL_ERROR_REPORTER);
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
   }
   taskVec.push_back(pusLowPrio);
 }
 
 void initmission::createPstTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*> &taskVec) {
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 #if OBSW_ADD_SPI_TEST_CODE == 0
   FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
-            "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
-            missedDeadlineFunc);
+      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
@@ -213,7 +211,7 @@ void initmission::createTestTasks(TaskFactory& factory,
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
   }
-#if RPI_ADD_SPI_TEST == 1
+#if OBSW_ADD_SPI_TEST_CODE == 1
   result = testTask->addComponent(objects::SPI_TEST);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
@@ -225,23 +223,23 @@ void initmission::createTestTasks(TaskFactory& factory,
     initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
   }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
-#if RPI_ADD_UART_TEST == 1
+#if OBSW_ADD_UART_TEST_CODE == 1
   result = testTask->addComponent(objects::UART_TEST);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
   }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
+  taskVec.push_back(testTask);
 
   bool startTestPst = true;
   static_cast<void>(startTestPst);
 #if OBSW_ADD_TEST_PST == 1
-    FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask("TEST_PST", 50,
-            PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
+  FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
+      "TEST_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
   result = pst::pstTest(pstTestTask);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::info << "initmission::initTasks: ACS PST empty or invalid" << std::endl;
     startTestPst = false;
   }
 #endif /* RPI_TEST_ACS_BOARD == 1 */
-
 }

bsp_linux_board/InitMission.h

@@ -1,9 +1,10 @@
 #ifndef BSP_LINUX_INITMISSION_H_
 #define BSP_LINUX_INITMISSION_H_
 
-#include "fsfw/tasks/Typedef.h"
 #include <vector>
 
+#include "fsfw/tasks/Typedef.h"
+
 class PeriodicTaskIF;
 class TaskFactory;
 
@@ -11,14 +12,12 @@ namespace initmission {
 void initMission();
 void initTasks();
 
-void createPstTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc,
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                     std::vector<PeriodicTaskIF*>& taskVec);
-void createTestTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc,
+void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                      std::vector<PeriodicTaskIF*>& taskVec);
 void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                     std::vector<PeriodicTaskIF*>& taskVec);
-};
+};  // namespace initmission
 
 #endif /* BSP_LINUX_INITMISSION_H_ */

bsp_linux_board/ObjectFactory.cpp

@@ -1,47 +1,46 @@
-#include <devConf.h>
 #include "ObjectFactory.h"
 
-#include "objects/systemObjectList.h"
+#include "OBSWConfig.h"
+#include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
-#include "OBSWConfig.h"
-#include "tmtc/apid.h"
-#include "tmtc/pusIds.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/tmtcpacket/pus/tm.h"
+#include "fsfw/tmtcservices/CommandingServiceBase.h"
+#include "fsfw/tmtcservices/PusServiceBase.h"
 #include "linux/boardtest/LibgpiodTest.h"
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"
-
 #include "mission/core/GenericFactory.h"
+#include "mission/devices/GPSHyperionHandler.h"
+#include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/utility/TmFunnel.h"
-#include <mission/devices/GPSHyperionHandler.h>
-#include "mission/devices/GyroADIS16507Handler.h"
-
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
-#include "fsfw/tmtcservices/CommandingServiceBase.h"
-#include "fsfw/tmtcservices/PusServiceBase.h"
-#include "fsfw/tmtcpacket/pus/tm.h"
-#include "fsfw/tasks/TaskFactory.h"
+#include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
 
 /* UDP server includes */
 #if OBSW_USE_TMTC_TCP_BRIDGE == 1
 #include <fsfw/src/fsfw/osal/common/TcpTmTcBridge.h>
 #include <fsfw/src/fsfw/osal/common/TcpTmTcServer.h>
 #else
-#include "fsfw/osal/common/UdpTmTcBridge.h"
 #include "fsfw/osal/common/UdpTcPollingTask.h"
+#include "fsfw/osal/common/UdpTmTcBridge.h"
 #endif
 
-#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
-#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
-#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
-#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
-#include "fsfw_hal/linux/rpi/GpioRPi.h"
-#include "fsfw_hal/common/gpio/GpioCookie.h"
-#include "fsfw_hal/linux/spi/SpiCookie.h"
-#include "fsfw_hal/linux/spi/SpiComIF.h"
 #include <fsfw_hal/linux/uart/UartComIF.h>
 #include <fsfw_hal/linux/uart/UartCookie.h>
 
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
+#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
+#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+#include "fsfw_hal/linux/spi/SpiComIF.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
   PusServiceBase::packetDestination = objects::TM_FUNNEL;
@@ -57,22 +56,10 @@ void Factory::setStaticFrameworkObjectIds() {
   TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }
 
-
-
 void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
   ObjectFactory::produceGenericObjects();
 
-#if OBSW_USE_TMTC_TCP_BRIDGE == 1
-    auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    tmtcBridge->setMaxNumberOfPacketsStored(50);
-    new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#else
-    auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-    tmtcBridge->setMaxNumberOfPacketsStored(50);
-    new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#endif
-
   GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
   GpioCookie* gpioCookie = nullptr;
   static_cast<void>(gpioCookie);
@@ -88,85 +75,93 @@ void ObjectFactory::produce(void* args){
     gpioCookie = new GpioCookie();
   }
   // TODO: Missing pin for Gyro 2
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN,
-            "MGM_0_LIS3", gpio::Direction::OUT, 1);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN, "MGM_0_LIS3",
+                            gpio::Direction::OUT, 1);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
                             "MGM_1_RM3100", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN,
-            "MGM_2_LIS3", gpio::Direction::OUT, 1);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN, "MGM_2_LIS3",
+                            gpio::Direction::OUT, 1);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
                             "MGM_3_RM3100", gpio::Direction::OUT, 1);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
                             "GYRO_0_ADIS", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN,
-            "GYRO_1_L3G", gpio::Direction::OUT, 1);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN, "GYRO_1_L3G",
+                            gpio::Direction::OUT, 1);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_ADIS_CS, gpio::GYRO_2_BCM_PIN,
                             "GYRO_2_ADIS", gpio::Direction::OUT, 1);
-    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN,
-            "GYRO_3_L3G", gpio::Direction::OUT, 1);
+  gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN, "GYRO_3_L3G",
+                            gpio::Direction::OUT, 1);
   gpioIF->addGpios(gpioCookie);
 
   spiDev = "/dev/spidev0.1";
-    spiCookie = new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
                     MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-    auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER,
-            objects::SPI_COM_IF, spiCookie, 0);
+  auto mgmLis3Handler =
+      new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   mgmLis3Handler->setStartUpImmediately();
 #if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
   mgmLis3Handler->setToGoToNormalMode(true);
 #endif
 
-    spiCookie = new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
                     RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-    auto mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER,
-            objects::SPI_COM_IF, spiCookie, 0);
+  auto mgmRm3100Handler =
+      new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   mgmRm3100Handler->setStartUpImmediately();
 #if FSFW_HAL_RM3100_MGM_DEBUG == 1
   mgmRm3100Handler->setToGoToNormalMode(true);
 #endif
 
-    spiCookie = new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev,
                     MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-    mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER,
-            objects::SPI_COM_IF, spiCookie, 0);
+  mgmLis3Handler =
+      new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   mgmLis3Handler->setStartUpImmediately();
 #if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
   mgmLis3Handler->setToGoToNormalMode(true);
 #endif
 
-    spiCookie = new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, spiDev,
                     RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-    mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER,
-            objects::SPI_COM_IF, spiCookie, 0);
+  mgmRm3100Handler =
+      new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   mgmRm3100Handler->setStartUpImmediately();
 #if FSFW_HAL_RM3100_MGM_DEBUG == 1
   mgmRm3100Handler->setToGoToNormalMode(true);
 #endif
 
-    spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
                     ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-    auto adisHandler = new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF,
-            spiCookie);
+  auto adisHandler =
+      new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
   adisHandler->setStartUpImmediately();
-    spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev,
-            L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-    auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
-            spiCookie, 0);
+  spiCookie =
+      new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  auto gyroL3gHandler =
+      new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   gyroL3gHandler->setStartUpImmediately();
 #if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
   gyroL3gHandler->setToGoToNormalMode(true);
 #endif
 
-    spiCookie = new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
+  spiCookie =
+      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
                     ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-    adisHandler = new GyroADIS16507Handler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF,
-            spiCookie);
+  adisHandler =
+      new GyroADIS16507Handler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
   adisHandler->setStartUpImmediately();
 
-    spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, spiDev,
-            L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-    gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_COM_IF,
-            spiCookie, 0);
+  spiCookie =
+      new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  gyroL3gHandler =
+      new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_COM_IF, spiCookie, 0);
   gyroL3gHandler->setStartUpImmediately();
 #if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
   gyroL3gHandler->setToGoToNormalMode(true);
@@ -180,14 +175,13 @@ void ObjectFactory::produce(void* args){
 }
 
 void ObjectFactory::createTestTasks() {
-
   new TestTask(objects::TEST_TASK);
 
-#if RPI_ADD_SPI_TEST == 1
+#if OBSW_ADD_SPI_TEST_CODE == 1
   new SpiTestClass(objects::SPI_TEST, gpioIF);
 #endif
 
-#if RPI_ADD_UART_TEST == 1
+#if OBSW_ADD_UART_TEST_CODE == 1
   new UartTestClass(objects::UART_TEST);
 #else
   new UartComIF(objects::UART_COM_IF);
@@ -217,20 +211,20 @@ void ObjectFactory::createTestTasks() {
 
   spiDev = "/dev/spidev0.1";
   spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
-            ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED,
-            nullptr, nullptr);
-    auto adisGyroHandler = new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
+                            ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
+                            spi::DEFAULT_ADIS16507_SPEED, nullptr, nullptr);
+  auto adisGyroHandler =
+      new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
   adisGyroHandler->setStartUpImmediately();
 #endif /* RPI_TEST_ADIS16507 == 1 */
 
 #if RPI_TEST_GPS_HANDLER == 1
-    UartCookie* uartCookie = new UartCookie(objects::GPS0_HANDLER, "/dev/serial0",
-            UartModes::CANONICAL, 9600, 1024);
+  UartCookie* uartCookie =
+      new UartCookie(objects::GPS0_HANDLER, "/dev/serial0", UartModes::CANONICAL, 9600, 1024);
   uartCookie->setToFlushInput(true);
   uartCookie->setReadCycles(6);
-    GPSHyperionHandler* gpsHandler = new GPSHyperionHandler(objects::GPS0_HANDLER,
-            objects::UART_COM_IF, uartCookie, false);
+  GPSHyperionHandler* gpsHandler =
+      new GPSHyperionHandler(objects::GPS0_HANDLER, objects::UART_COM_IF, uartCookie, false);
   gpsHandler->setStartUpImmediately();
 #endif
-
 }

bsp_linux_board/ObjectFactory.h

@@ -1,12 +1,11 @@
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_
 
-
 namespace ObjectFactory {
 void setStatics();
 void produce(void* args);
 
 void createTestTasks();
-};
+};  // namespace ObjectFactory
 
 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_linux_board/boardconfig/CMakeLists.txt

@@ -1,7 +1,7 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	print.c
 )
 
-target_include_directories(${TARGET_NAME} PUBLIC
+target_include_directories(${OBSW_NAME} PUBLIC
 	${CMAKE_CURRENT_SOURCE_DIR}
 )

bsp_linux_board/boardconfig/gcov.h

@@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
   sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif
 

bsp_linux_board/boardconfig/print.c

@@ -1,4 +1,4 @@
-#include <bsp_q7s/boardconfig/print.h>
+#include <bsp_linux_board/boardconfig/print.h>
 #include <stdio.h>
 
 void printChar(const char* character, bool errStream) {
@@ -8,7 +8,3 @@ void printChar(const char* character, bool errStream) {
   }
   putc(*character, stdout);
 }
-
-
-
-

bsp_linux_board/boardtest/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 )
 
 

bsp_linux_board/main.cpp

@@ -1,12 +1,11 @@
+#include <iostream>
+
 #include "InitMission.h"
 #include "OBSWConfig.h"
 #include "OBSWVersion.h"
-
 #include "fsfw/FSFWVersion.h"
 #include "fsfw/tasks/TaskFactory.h"
 
-#include <iostream>
-
 #ifdef RASPBERRY_PI
 static const char* const BOARD_NAME = "Raspberry Pi";
 #elif defined(BEAGLEBONEBLACK)
@@ -19,13 +18,12 @@ static const char* const BOARD_NAME = "Unknown Board";
  * @brief 	    This is the main program and entry point for the Raspberry Pi.
  * @return
  */
-int main(void)
-{
+int main(void) {
   std::cout << "-- EIVE OBSW --" << std::endl;
   std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
-    std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION <<
-            "." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION <<
-            FSFW_REVISION << "--"  << std::endl;
+  std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
+            << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << FSFW_REVISION
+            << "--" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
   initmission::initMission();
@@ -35,5 +33,3 @@ int main(void)
     TaskFactory::delayTask(5000);
   }
 }
-
-

bsp_q7s/CMakeLists.txt

@@ -1,17 +1,25 @@
-target_sources(${TARGET_NAME} PUBLIC
+#simple mode
+add_executable(${SIMPLE_OBSW_NAME} EXCLUDE_FROM_ALL)
+target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
+target_sources(${SIMPLE_OBSW_NAME} PUBLIC
+	main.cpp
+)
+#I think this is unintentional? (produces linker errors for stuff in /linux)
+target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC
+    ${LIB_FSFW_NAME}
+)
+target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
+add_subdirectory(simple)
+
+target_sources(${OBSW_NAME} PUBLIC
 	main.cpp
 )
 
 add_subdirectory(boardtest)
 
-if(Q7S_SIMPLE_MODE)
-    add_subdirectory(simple)
-else()
 add_subdirectory(boardconfig)
 add_subdirectory(comIF)
-    add_subdirectory(gpio)
 add_subdirectory(core)
 add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(devices)
-endif()

bsp_q7s/boardconfig/CMakeLists.txt

@@ -1,7 +1,12 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	print.c
 )
 
-target_include_directories(${TARGET_NAME} PUBLIC
+target_sources(${SIMPLE_OBSW_NAME} PRIVATE
+	print.c
+)
+
+
+target_include_directories(${OBSW_NAME} PUBLIC
 	${CMAKE_CURRENT_SOURCE_DIR}
 )

bsp_q7s/boardconfig/busConf.h

@@ -3,98 +3,98 @@
 
 namespace q7s {
 
-static constexpr char SPI_DEFAULT_DEV[] = "/dev/spidev2.0";
-static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0";
+static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
+static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";
 
-static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1";
+static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-eive";
 
-static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3";
-static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4";
-static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL5";
-static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL8";
+static constexpr char UART_GNSS_DEV[] = "/dev/ul-gps";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul-plmpsoc";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul-plsv";
+static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul-syrlinks";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul-str";
 
-static constexpr char UART_GNSS_0_DEV[] = "/dev/ttyUL0";
-static constexpr char UART_GNSS_1_DEV[] = "/dev/ttyUL2";
+static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
+static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
+static constexpr char UIO_PDEC_RAM[] = "/dev/uio3";
+static constexpr char UIO_PTME[] = "/dev/uio1";
+static constexpr int MAP_ID_PTME_CONFIG = 3;
 
-/**************************************************************/
-/** OBC1E                                                     */
-/**************************************************************/
-static constexpr char GPIO_MULTIPURPOSE_1V8_OBC1D[] = "/amba_pl/gpio@42020000";
-static const char* const GPIO_GYRO_ADIS_LABEL = GPIO_MULTIPURPOSE_1V8_OBC1D;
-static constexpr uint32_t GPIO_GYRO_0_ADIS_CS = 0;      // Package Pin: W20
-static constexpr uint32_t GPIO_GYRO_2_ADIS_CS = 2;      // AA22
+namespace uiomapids {
+static const int PTME_VC0 = 0;
+static const int PTME_VC1 = 1;
+static const int PTME_VC2 = 2;
+static const int PTME_VC3 = 3;
+static const int PTME_CONFIG = 4;
+}  // namespace uiomapids
 
-/**************************************************************/
-/** OBC1F B0                                                  */
-/**************************************************************/
-static constexpr char GPIO_FLEX_OBC1F_B0[] = "/amba_pl/gpio@42030000";
-static constexpr uint32_t GPIO_FLEX_OBC1F_B0_WIDTH = 20;
-static const char* const GPIO_ACS_BOARD_DEFAULT_LABEL = GPIO_FLEX_OBC1F_B0;
-static const char* const GPIO_RW_DEFAULT_LABEL = GPIO_FLEX_OBC1F_B0;
-static const char* const GPIO_RAD_SENSOR_LABEL = GPIO_FLEX_OBC1F_B0;
+namespace gpioNames {
 
+static constexpr char GYRO_0_ADIS_CS[] = "gyro_0_adis_chip_select";
+static constexpr char GYRO_1_L3G_CS[] = "gyro_1_l3g_chip_select";
+static constexpr char GYRO_2_ADIS_CS[] = "gyro_2_adis_chip_select";
+static constexpr char GYRO_3_L3G_CS[] = "gyro_3_l3g_chip_select";
+static constexpr char MGM_0_CS[] = "mgm_0_lis3_chip_select";
+static constexpr char MGM_1_CS[] = "mgm_1_rm3100_chip_select";
+static constexpr char MGM_2_CS[] = "mgm_2_lis3_chip_select";
+static constexpr char MGM_3_CS[] = "mgm_3_rm3100_chip_select";
+static constexpr char RESET_GNSS_0[] = "reset_gnss_0";
+static constexpr char RESET_GNSS_1[] = "reset_gnss_1";
+static constexpr char GNSS_0_ENABLE[] = "enable_gnss_0";
+static constexpr char GNSS_1_ENABLE[] = "enable_gnss_1";
+static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
+static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
+static constexpr char GNSS_SELECT[] = "gnss_mux_select";
+static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
 
-static constexpr uint32_t GPIO_RW_0_CS = 7;             // B20
-static constexpr uint32_t GPIO_RW_1_CS = 3;             // G22
-static constexpr uint32_t GPIO_RW_2_CS = 11;            // E18
-static constexpr uint32_t GPIO_RW_3_CS = 6;             // B19
+static constexpr char HEATER_0[] = "heater0";
+static constexpr char HEATER_1[] = "heater1";
+static constexpr char HEATER_2[] = "heater2";
+static constexpr char HEATER_3[] = "heater3";
+static constexpr char HEATER_4[] = "heater4";
+static constexpr char HEATER_5[] = "heater5";
+static constexpr char HEATER_6[] = "heater6";
+static constexpr char HEATER_7[] = "heater7";
+static constexpr char SA_DPL_PIN_0[] = "sa_dpl_0";
+static constexpr char SA_DPL_PIN_1[] = "sa_dpl_1";
+static constexpr char SPI_MUX_BIT_0_PIN[] = "spi_mux_bit_0";
+static constexpr char SPI_MUX_BIT_1_PIN[] = "spi_mux_bit_1";
+static constexpr char SPI_MUX_BIT_2_PIN[] = "spi_mux_bit_2";
+static constexpr char SPI_MUX_BIT_3_PIN[] = "spi_mux_bit_3";
+static constexpr char SPI_MUX_BIT_4_PIN[] = "spi_mux_bit_4";
+static constexpr char SPI_MUX_BIT_5_PIN[] = "spi_mux_bit_5";
+static constexpr char EN_RW_CS[] = "en_rw_cs";
+static constexpr char EN_RW_1[] = "enable_rw_1";
+static constexpr char EN_RW_2[] = "enable_rw_2";
+static constexpr char EN_RW_3[] = "enable_rw_3";
+static constexpr char EN_RW_4[] = "enable_rw_4";
 
-static constexpr uint32_t GPIO_GYRO_1_L3G_CS = 18;      // N22
-static constexpr uint32_t GPIO_GYRO_3_L3G_CS = 1;       // M21
-static constexpr uint32_t GPIO_MGM_0_LIS3_CS = 5;       // C18
-static constexpr uint32_t GPIO_MGM_1_RM3100_CS = 16;    // A16
-static constexpr uint32_t GPIO_MGM_3_RM3100_CS = 10;    // C17
+static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
+static constexpr char ENABLE_RADFET[] = "enable_radfet";
+static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
+static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
+static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
+static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
+static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
+static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
+static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
+static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
+static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";
+static constexpr char RS485_EN_TX_DATA[] = "tx_data_enable_ltc2872";
+static constexpr char RS485_EN_RX_CLOCK[] = "rx_clock_enable_ltc2872";
+static constexpr char RS485_EN_RX_DATA[] = "rx_data_enable_ltc2872";
+static constexpr char PDEC_RESET[] = "pdec_reset";
 
-// Active low enable pin (needs to be driven low for regular operations)
-static constexpr uint32_t GPIO_GYRO_0_ENABLE = 2;       // H22
+static constexpr char PL_PCDU_ENABLE_VBAT0[] = "enable_plpcdu_vbat0";
+static constexpr char PL_PCDU_ENABLE_VBAT1[] = "enable_plpcdu_vbat1";
+static constexpr char PL_PCDU_ENABLE_DRO[] = "enable_plpcdu_dro";
+static constexpr char PL_PCDU_ENABLE_X8[] = "enable_plpcdu_x8";
+static constexpr char PL_PCDU_ENABLE_TX[] = "enable_plpcdu_tx";
+static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa";
+static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa";
+static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select";
 
-// Active low reset pin (needs to be driven high for regular operations)
-static constexpr uint32_t GPIO_RESET_GNSS_0 = 9;        // C22
-static constexpr uint32_t GPIO_RESET_GNSS_1 = 12;       // B21
-
-static constexpr uint32_t GPIO_RAD_SENSOR_CS = 19;      // R18
-
-/**************************************************************/
-/** OBC1F B1                                                  */
-/**************************************************************/
-static constexpr char GPIO_FLEX_OBC1F_B1[] = "/amba_pl/gpio@42030000";
-// Need to use chip name here for now because the label name is the name for
-// gpiochip 5 and gpiochip6
-static constexpr char GPIO_FLEX_OBC1F_B1_CHIP[] = "gpiochip6";
-static const char* const GPIO_MGM2_LIS3_LABEL = GPIO_FLEX_OBC1F_B1_CHIP;
-static constexpr uint32_t GPIO_MGM_2_LIS3_CS = 0;       // D18
-
-/**************************************************************/
-/** OBC1C                                                     */
-/**************************************************************/
-static constexpr char GPIO_3V3_OBC1C[] = "/amba_pl/gpio@42040000";
-static const char* const GPIO_HEATER_LABEL = GPIO_3V3_OBC1C;
-static const char* const GPIO_SOLAR_ARR_DEPL_LABEL = GPIO_3V3_OBC1C;
-static constexpr uint32_t GPIO_HEATER_0_PIN = 6;
-static constexpr uint32_t GPIO_HEATER_1_PIN = 12;
-static constexpr uint32_t GPIO_HEATER_2_PIN = 7;
-static constexpr uint32_t GPIO_HEATER_3_PIN = 5;
-static constexpr uint32_t GPIO_HEATER_4_PIN = 3;
-static constexpr uint32_t GPIO_HEATER_5_PIN = 0;
-static constexpr uint32_t GPIO_HEATER_6_PIN = 1;
-static constexpr uint32_t GPIO_HEATER_7_PIN = 11;
-static constexpr uint32_t GPIO_GYRO_2_ENABLE = 18;      // F22
-
-static constexpr uint32_t GPIO_SOL_DEPL_SA_0_PIN = 4;
-static constexpr uint32_t GPIO_SOL_DEPL_SA_1_PIN = 2;
-
-static constexpr char GPIO_RW_SPI_MUX_LABEL[] = "zynq_gpio";
-// Uses EMIO interface to PL, starts at 54
-static constexpr uint32_t GPIO_RW_SPI_MUX_CS = 54;
-
-static constexpr uint32_t SPI_MUX_BIT_1 = 13;
-static constexpr uint32_t SPI_MUX_BIT_2 = 14;
-static constexpr uint32_t SPI_MUX_BIT_3 = 15;
-static constexpr uint32_t SPI_MUX_BIT_4 = 16;
-static constexpr uint32_t SPI_MUX_BIT_5 = 17;
-static constexpr uint32_t SPI_MUX_BIT_6 = 9;
-static constexpr uint32_t EN_RW_CS = 17;
-
-}
+}  // namespace gpioNames
+}  // namespace q7s
 
 #endif /* BSP_Q7S_BOARDCONFIG_BUSCONF_H_ */

bsp_q7s/boardconfig/gcov.h

@@ -7,7 +7,8 @@ extern "C" void __gcov_flush();
 #else
 void __gcov_flush() {
   sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
-			"coverage information is desired.\n" << std::flush;
+               "coverage information is desired.\n"
+            << std::flush;
 }
 #endif
 

bsp_q7s/boardconfig/print.c

@@ -8,7 +8,3 @@ void printChar(const char* character, bool errStream) {
   }
   putc(*character, stdout);
 }
-
-
-
-

bsp_q7s/boardconfig/q7sConfig.h.in

@@ -3,8 +3,6 @@
 
 #include <cstdint>
 
-#cmakedefine01 Q7S_SIMPLE_MODE
-
 /*******************************************************************/
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/

bsp_q7s/boardtest/CMakeLists.txt

@@ -1,8 +1,10 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
     FileSystemTest.cpp
     Q7STestTask.cpp
 )
 
-
-
-
+if(EIVE_BUILD_Q7S_SIMPLE_MODE)
+    target_sources(${SIMPLE_OBSW_NAME} PRIVATE
+        FileSystemTest.cpp
+    )
+endif()

bsp_q7s/boardtest/FileSystemTest.cpp

@@ -1,13 +1,11 @@
 #include "FileSystemTest.h"
+
+#include <cstdlib>
+#include <iostream>
+
 #include "fsfw/timemanager/Stopwatch.h"
 
-#include <iostream>
-#include <cstdlib>
-
-enum SdCard {
-    SDC0,
-    SDC1
-};
+enum SdCard { SDC0, SDC1 };
 
 FileSystemTest::FileSystemTest() {
   using namespace std;
@@ -22,5 +20,4 @@ FileSystemTest::FileSystemTest() {
   // stopwatch.stop(true);
 }
 
-FileSystemTest::~FileSystemTest() {
-}
+FileSystemTest::~FileSystemTest() {}

bsp_q7s/boardtest/FileSystemTest.h

@@ -5,9 +5,8 @@ class FileSystemTest {
  public:
   FileSystemTest();
   virtual ~FileSystemTest();
+
  private:
 };
 
-
-
 #endif /* BSP_Q7S_BOARDTEST_FILESYSTEMTEST_H_ */

bsp_q7s/boardtest/Q7STestTask.cpp

@@ -1,36 +1,52 @@
+#include "Q7STestTask.h"
+
 #include <bsp_q7s/core/CoreController.h>
 #include <bsp_q7s/memory/FileSystemHandler.h>
 #include <fsfw/objectmanager/ObjectManager.h>
-#include "Q7STestTask.h"
+#include <gps.h>
+#include <libgpsmm.h>
+
+#include <cstdio>
+#include <ctime>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <nlohmann/json.hpp>
 
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
-
-#include "fsfw/timemanager/Stopwatch.h"
 #include "fsfw/tasks/TaskFactory.h"
-
+#include "fsfw/timemanager/Stopwatch.h"
 #include "test/DummyParameter.h"
 
-#include <nlohmann/json.hpp>
-
-#include <iostream>
-#include <fstream>
-#include <cstdio>
-
 Q7STestTask::Q7STestTask(object_id_t objectId) : TestTask(objectId) {
+  doTestSdCard = false;
+  doTestScratchApi = false;
+  doTestGps = false;
 }
 
 ReturnValue_t Q7STestTask::performOneShotAction() {
-    //testSdCard();
-    //testScratchApi();
+  if (doTestSdCard) {
+    testSdCard();
+  }
+  if (doTestScratchApi) {
+    testScratchApi();
+  }
   // testJsonLibDirect();
   // testDummyParams();
   // testProtHandler();
-    //FsOpCodes opCode = FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY;
-    //testFileSystemHandlerDirect(opCode);
+  FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
+  testFileSystemHandlerDirect(opCode);
   return TestTask::performOneShotAction();
 }
 
+ReturnValue_t Q7STestTask::performPeriodicAction() {
+  if (doTestGps) {
+    testGpsDaemon();
+  }
+  return TestTask::performPeriodicAction();
+}
+
 void Q7STestTask::testSdCard() {
   using namespace std;
   Stopwatch stopwatch;
@@ -47,8 +63,7 @@ void Q7STestTask::testSdCard() {
     while (iss >> word) {
       if (word == "on") {
         sif::info << "SD card " << static_cast<int>(idx) << " is on" << endl;
-            }
-            else if(word == "off") {
+      } else if (word == "off") {
         sif::info << "SD card " << static_cast<int>(idx) << " is off" << endl;
       }
     }
@@ -118,7 +133,6 @@ void Q7STestTask::testDummyParams() {
 
   ReturnValue_t result = param.readJsonFile();
   if (result != HasReturnvaluesIF::RETURN_OK) {
-
   }
 
   param.setValue(DummyParameter::DUMMY_KEY_PARAM_1, 3);
@@ -127,8 +141,18 @@ void Q7STestTask::testDummyParams() {
   param.writeJsonFile();
   param.print();
 
-    int test = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1);
-    std::string test2 = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2);
+  int test = 0;
+  result = param.getValue<int>(DummyParameter::DUMMY_KEY_PARAM_1, test);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
+                 << " does not exist" << std::endl;
+  }
+  std::string test2;
+  result = param.getValue<std::string>(DummyParameter::DUMMY_KEY_PARAM_2, test2);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1
+                 << " does not exist" << std::endl;
+  }
   sif::info << "Test value (3 expected): " << test << std::endl;
   sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl;
 }
@@ -136,8 +160,8 @@ void Q7STestTask::testDummyParams() {
 ReturnValue_t Q7STestTask::initialize() {
   coreController = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
   if (coreController == nullptr) {
-        sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object" <<
-                std::endl;
+    sif::warning << "Q7STestTask::initialize: Could not retrieve CORE_CONTROLLER object"
+                 << std::endl;
   }
   return TestTask::initialize();
 }
@@ -146,16 +170,14 @@ void Q7STestTask::testProtHandler() {
   bool opPerformed = false;
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   // If any chips are unlocked, lock them here
-    result = coreController->setBootCopyProtection(
-            CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true,
+  result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
                                                  opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
 
   // unlock own copy
-    result = coreController->setBootCopyProtection(
-            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false,
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
                                                  opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
@@ -169,8 +191,7 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock own copy
-    result = coreController->setBootCopyProtection(
-            CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true,
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
                                                  opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
@@ -184,8 +205,7 @@ void Q7STestTask::testProtHandler() {
   }
 
   // unlock specific copy
-    result = coreController->setBootCopyProtection(
-            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false,
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
                                                  opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
@@ -199,8 +219,7 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock specific copy
-    result = coreController->setBootCopyProtection(
-            CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true,
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
                                                  opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
@@ -214,9 +233,28 @@ void Q7STestTask::testProtHandler() {
   }
 }
 
+void Q7STestTask::testGpsDaemon() {
+  gpsmm gpsmm(GPSD_SHARED_MEMORY, 0);
+  gps_data_t* gps;
+  gps = gpsmm.read();
+  if (gps == nullptr) {
+    sif::warning << "Q7STestTask: Reading GPS data failed" << std::endl;
+  }
+  sif::info << "-- Q7STestTask: GPS shared memory read test --" << std::endl;
+  time_t timeRaw = gps->fix.time.tv_sec;
+  std::tm* time = gmtime(&timeRaw);
+  sif::info << "Time: " << std::put_time(time, "%c %Z") << std::endl;
+  sif::info << "Visible satellites: " << gps->satellites_visible << std::endl;
+  sif::info << "Satellites used: " << gps->satellites_used << std::endl;
+  sif::info << "Fix (0:Not Seen|1:No Fix|2:2D|3:3D): " << gps->fix.mode << std::endl;
+  sif::info << "Latitude: " << gps->fix.latitude << std::endl;
+  sif::info << "Longitude: " << gps->fix.longitude << std::endl;
+  sif::info << "Altitude(MSL): " << gps->fix.altMSL << std::endl;
+  sif::info << "Speed(m/s): " << gps->fix.speed << std::endl;
+}
+
 void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
-    auto fsHandler = ObjectManager::instance()->
-            get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
+  auto fsHandler = ObjectManager::instance()->get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
   if (fsHandler == nullptr) {
     sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
                  << std::endl;
@@ -227,7 +265,7 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
   // Lambda for common code
   auto createNonEmptyTmpDir = [&]() {
     if (not std::filesystem::exists("/tmp/test")) {
-            result = fsHandler->createDirectory("/tmp/test", &cfg);
+      result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
       if (result != HasReturnvaluesIF::RETURN_OK) {
         return result;
       }
@@ -245,14 +283,13 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
     return result;
   };
 
-
   switch (opCode) {
     case (FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
       // No mount prefix, cause file is created in tmp
       cfg.useMountPrefix = false;
       sif::info << "Creating empty file in /tmp folder" << std::endl;
       // Do not delete file, user can check existence in shell
-        fsHandler->createFile("/tmp", "test.txt", nullptr, 0, &cfg);
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
       break;
     }
     case (FsOpCodes::REMOVE_TMP_FILE): {
@@ -262,13 +299,12 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
       if (not std::filesystem::exists("/tmp/test.txt")) {
         // Creating sample file
         sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
-            fsHandler->createFile("/tmp", "test.txt", nullptr, 0, &cfg);
+        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
       }
       result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
       if (result == HasReturnvaluesIF::RETURN_OK) {
         sif::info << "File removed successfully" << std::endl;
-        }
-        else {
+      } else {
         sif::warning << "File removal failed!" << std::endl;
       }
       break;
@@ -278,11 +314,10 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
       cfg.useMountPrefix = false;
       sif::info << "Creating empty file in /tmp folder" << std::endl;
       // Do not delete file, user can check existence in shell
-        ReturnValue_t result = fsHandler->createDirectory("/tmp/test", &cfg);
+      ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
       if (result == HasReturnvaluesIF::RETURN_OK) {
         sif::info << "Directory created successfully" << std::endl;
-        }
-        else {
+      } else {
         sif::warning << "Directory creation failed!" << std::endl;
       }
       break;
@@ -291,17 +326,15 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
       // No mount prefix, cause file is created in tmp
       cfg.useMountPrefix = false;
       if (not std::filesystem::exists("/tmp/test")) {
-            result = fsHandler->createDirectory("/tmp/test", &cfg);
-        }
-        else {
+        result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
+      } else {
         // Delete any leftover files to regular dir removal works
         std::remove("/tmp/test/*");
       }
-        result = fsHandler->removeDirectory("/tmp/test", false, &cfg);
+      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
       if (result == HasReturnvaluesIF::RETURN_OK) {
         sif::info << "Directory removed successfully" << std::endl;
-        }
-        else {
+      } else {
         sif::warning << "Directory removal failed!" << std::endl;
       }
       break;
@@ -311,11 +344,10 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
       if (result != HasReturnvaluesIF::RETURN_OK) {
         return;
       }
-        result = fsHandler->removeDirectory("/tmp/test", true, &cfg);
+      result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
       if (result == HasReturnvaluesIF::RETURN_OK) {
         sif::info << "Directory removed recursively successfully" << std::endl;
-        }
-        else {
+      } else {
         sif::warning << "Recursive directory removal failed!" << std::endl;
       }
       break;
@@ -325,13 +357,41 @@ void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
       if (result != HasReturnvaluesIF::RETURN_OK) {
         return;
       }
-        result = fsHandler->removeDirectory("/tmp/test", false, &cfg);
+      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
       if (result != HasReturnvaluesIF::RETURN_OK) {
         sif::info << "Directory removal attempt failed as expected" << std::endl;
-        }
-        else {
+      } else {
         sif::warning << "Directory removal worked when it should not have!" << std::endl;
       }
+      break;
+    }
+    case (FsOpCodes::RENAME_FILE): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
+      // Do not delete file, user can check existence in shell
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
+      break;
+    }
+    case (FsOpCodes::APPEND_TO_FILE): {
+      // No mount prefix, cause file is created in tmp
+      cfg.useMountPrefix = false;
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      if (std::filesystem::exists("/tmp/test.txt")) {
+        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
+      }
+      sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
+      std::string content = "Hello World\n";
+      // Do not delete file, user can check existence in shell
+      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
+      fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(content.data()),
+                              content.size(), 0, &cfg);
     }
   }
 }

bsp_q7s/boardtest/Q7STestTask.h

@@ -3,14 +3,24 @@
 
 #include "test/testtasks/TestTask.h"
 
+class CoreController;
+
 class Q7STestTask : public TestTask {
  public:
   Q7STestTask(object_id_t objectId);
 
   ReturnValue_t initialize() override;
+
  private:
+  bool doTestSdCard = false;
+  bool doTestScratchApi = false;
+  bool doTestGps = false;
+
   CoreController* coreController = nullptr;
   ReturnValue_t performOneShotAction() override;
+  ReturnValue_t performPeriodicAction() override;
+
+  void testGpsDaemon();
 
   void testSdCard();
   void fileTests();
@@ -27,9 +37,10 @@ private:
     REMOVE_EMPTY_DIR_IN_TMP,
     ATTEMPT_DIR_REMOVAL_NON_EMPTY,
     REMOVE_FILLED_DIR_IN_TMP,
+    RENAME_FILE,
+    APPEND_TO_FILE,
   };
   void testFileSystemHandlerDirect(FsOpCodes opCode);
 };
 
-
 #endif /* BSP_Q7S_BOARDTEST_Q7STESTTASK_H_ */

bsp_q7s/callbacks/CMakeLists.txt

@@ -1,4 +1,6 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	rwSpiCallback.cpp
 	gnssCallback.cpp
+	pcduSwitchCb.cpp
+	gpioCallbacks.cpp
 )

bsp_q7s/callbacks/gnssCallback.cpp

@@ -1,6 +1,6 @@
 #include "gnssCallback.h"
-#include "devices/gpioIds.h"
 
+#include "devices/gpioIds.h"
 #include "fsfw/tasks/TaskFactory.h"
 
 ReturnValue_t gps::triggerGpioResetPin(void* args) {
@@ -15,8 +15,7 @@ ReturnValue_t gps::triggerGpioResetPin(void *args) {
   if (resetArgs->gnss1) {
     gpioId = gpioIds::GNSS_1_NRESET;
 
-    }
-    else {
+  } else {
     gpioId = gpioIds::GNSS_0_NRESET;
   }
   resetArgs->gpioComIF->pullLow(gpioId);

bsp_q7s/callbacks/gnssCallback.h

@@ -1,8 +1,8 @@
 #ifndef BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
 #define BSP_Q7S_CALLBACKS_GNSSCALLBACK_H_
 
-#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 
 struct ResetArgs {
   bool gnss1 = false;

bsp_q7s/callbacks/gpioCallbacks.cpp

@@ -0,0 +1,487 @@
+#include "gpioCallbacks.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+
+#include "busConf.h"
+
+namespace gpioCallbacks {
+
+GpioIF* gpioComInterface;
+
+void initSpiCsDecoder(GpioIF* gpioComIF) {
+  using namespace gpio;
+  ReturnValue_t result;
+
+  if (gpioComIF == nullptr) {
+    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
+    return;
+  }
+
+  gpioComInterface = gpioComIF;
+
+  GpioCookie* spiMuxGpios = new GpioCookie;
+
+  GpiodRegularByLineName* spiMuxBit = nullptr;
+  /** Setting mux bit 1 to low will disable IC21 on the interface board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
+                                         Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_0, spiMuxBit);
+  /** Setting mux bit 2 to low disables IC1 on the TCS board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 2",
+                                         Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
+  /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
+
+  /** The following gpios can take arbitrary initial values */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
+  GpiodRegularByLineName* enRwDecoder = new GpiodRegularByLineName(
+      q7s::gpioNames::EN_RW_CS, "EN_RW_CS", Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
+
+  result = gpioComInterface->addGpios(spiMuxGpios);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
+    return;
+  }
+}
+
+void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
+                          void* args) {
+  using namespace gpio;
+  if (gpioComInterface == nullptr) {
+    sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
+               << "to specify gpioComIF" << std::endl;
+    return;
+  }
+
+  /* Reading is not supported by the callback function */
+  if (gpioOp == gpio::GpioOperation::READ) {
+    return;
+  }
+
+  if (value == Levels::HIGH) {
+    switch (gpioId) {
+      case (gpioIds::RTD_IC_3): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_4): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_5): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_6): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_7): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_8): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_9): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_10): {
+        disableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_11): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_12): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_13): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_14): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_15): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_16): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_17): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_18): {
+        disableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_0): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_1): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_2): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_3): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_4): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_5): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_6): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_7): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_8): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_9): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_10): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_11): {
+        disableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_RW1): {
+        disableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW2): {
+        disableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW3): {
+        disableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW4): {
+        disableRwDecoder();
+        break;
+      }
+      default:
+        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
+    }
+  } else if (value == Levels::LOW) {
+    switch (gpioId) {
+      case (gpioIds::RTD_IC_3): {
+        selectY7();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_4): {
+        selectY6();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_5): {
+        selectY5();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_6): {
+        selectY4();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_7): {
+        selectY3();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_8): {
+        selectY2();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_9): {
+        selectY1();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_10): {
+        selectY0();
+        enableDecoderTcsIc1();
+        break;
+      }
+      case (gpioIds::RTD_IC_11): {
+        selectY7();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_12): {
+        selectY6();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_13): {
+        selectY5();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_14): {
+        selectY4();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_15): {
+        selectY3();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_16): {
+        selectY2();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_17): {
+        selectY1();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::RTD_IC_18): {
+        selectY0();
+        enableDecoderTcsIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_0): {
+        selectY0();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_1): {
+        selectY1();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_2): {
+        selectY2();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_3): {
+        selectY3();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_4): {
+        selectY4();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_5): {
+        selectY5();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
+      case (gpioIds::CS_SUS_6): {
+        selectY0();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_7): {
+        selectY1();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_8): {
+        selectY2();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_9): {
+        selectY3();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_10): {
+        selectY4();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_SUS_11): {
+        selectY5();
+        enableDecoderInterfaceBoardIc2();
+        break;
+      }
+      case (gpioIds::CS_RW1): {
+        selectY0();
+        enableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW2): {
+        selectY1();
+        enableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW3): {
+        selectY2();
+        enableRwDecoder();
+        break;
+      }
+      case (gpioIds::CS_RW4): {
+        selectY3();
+        enableRwDecoder();
+        break;
+      }
+      default:
+        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
+    }
+  } else {
+    sif::debug << "spiCsDecoderCallback: Invalid value. Must be 0 or 1" << std::endl;
+  }
+}
+
+void enableDecoderTcsIc1() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void enableDecoderTcsIc2() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+}
+
+void enableDecoderInterfaceBoardIc1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void enableDecoderInterfaceBoardIc2() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+}
+
+void disableDecoderTcsIc1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void disableDecoderTcsIc2() {
+  // DO NOT CHANGE THE ORDER HERE
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+}
+
+void disableDecoderInterfaceBoardIc1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void disableDecoderInterfaceBoardIc2() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void enableRwDecoder() { gpioComInterface->pullHigh(gpioIds::EN_RW_CS); }
+
+void disableRwDecoder() { gpioComInterface->pullLow(gpioIds::EN_RW_CS); }
+
+void selectY0() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY2() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY3() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY4() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY5() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY6() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void selectY7() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void disableAllDecoder() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::EN_RW_CS);
+}
+
+}  // namespace gpioCallbacks

bsp_q7s/callbacks/gpioCallbacks.h

@@ -0,0 +1,73 @@
+#ifndef LINUX_GPIO_GPIOCALLBACKS_H_
+#define LINUX_GPIO_GPIOCALLBACKS_H_
+
+#include <fsfw_hal/common/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
+
+namespace gpioCallbacks {
+
+/**
+ * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
+ *          the TCS Board and the interface board.
+ */
+void initSpiCsDecoder(GpioIF* gpioComIF);
+
+/**
+ * @brief   This function implements the decoding to multiply gpios by using the decoder
+ *          chips SN74LVC138APWR on the TCS board and the interface board.
+ */
+void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
+                          void* args);
+
+/**
+ * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
+ *          on the TCS board which is named to IC1 in the schematic.
+ */
+void enableDecoderTcsIc1();
+
+/**
+ * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
+ *          on the TCS board which is named to IC2 in the schematic.
+ */
+void enableDecoderTcsIc2();
+
+/**
+ * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
+ *          on the inteface board board which is named to IC21 in the schematic.
+ */
+void enableDecoderInterfaceBoardIc1();
+
+/**
+ * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
+ *          on the inteface board board which is named to IC22 in the schematic.
+ */
+void enableDecoderInterfaceBoardIc2();
+
+void disableDecoderTcsIc1();
+void disableDecoderTcsIc2();
+void disableDecoderInterfaceBoardIc1();
+void disableDecoderInterfaceBoardIc2();
+
+/**
+ * @brief   Enables the reaction wheel chip select decoder (IC3).
+ */
+void enableRwDecoder();
+void disableRwDecoder();
+
+/**
+ * @brief   This function disables all decoder.
+ */
+void disableAllDecoder();
+
+/** The following functions enable the appropriate channel of the currently enabled decoder */
+void selectY0();
+void selectY1();
+void selectY2();
+void selectY3();
+void selectY4();
+void selectY5();
+void selectY6();
+void selectY7();
+}  // namespace gpioCallbacks
+
+#endif /* LINUX_GPIO_GPIOCALLBACKS_H_ */

bsp_q7s/callbacks/pcduSwitchCb.cpp

@@ -0,0 +1,32 @@
+#include "pcduSwitchCb.h"
+
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+
+#include "devices/gpioIds.h"
+
+void pcdu::switchCallback(GOMSPACE::Pdu pdu, uint8_t channel, bool state, void* args) {
+  LinuxLibgpioIF* gpioComIF = reinterpret_cast<LinuxLibgpioIF*>(args);
+  if (gpioComIF == nullptr) {
+    return;
+  }
+  if (pdu == GOMSPACE::Pdu::PDU1) {
+    PDU1::SwitchChannels typedChannel = static_cast<PDU1::SwitchChannels>(channel);
+    if (typedChannel == PDU1::SwitchChannels::ACS_A_SIDE) {
+      if (state) {
+        gpioComIF->pullHigh(gpioIds::GNSS_0_NRESET);
+      } else {
+        gpioComIF->pullLow(gpioIds::GNSS_0_NRESET);
+      }
+    }
+
+  } else if (pdu == GOMSPACE::Pdu::PDU2) {
+    PDU2::SwitchChannels typedChannel = static_cast<PDU2::SwitchChannels>(channel);
+    if (typedChannel == PDU2::SwitchChannels::ACS_B_SIDE) {
+      if (state) {
+        gpioComIF->pullHigh(gpioIds::GNSS_1_NRESET);
+      } else {
+        gpioComIF->pullLow(gpioIds::GNSS_1_NRESET);
+      }
+    }
+  }
+}

bsp_q7s/callbacks/pcduSwitchCb.h

@@ -0,0 +1,14 @@
+#ifndef BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_
+#define BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_
+
+#include <cstdint>
+
+#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
+
+namespace pcdu {
+
+void switchCallback(GOMSPACE::Pdu pdu, uint8_t channel, bool state, void* args);
+
+}
+
+#endif /* BSP_Q7S_CALLBACKS_PCDUSWITCHCB_H_ */

bsp_q7s/callbacks/rwSpiCallback.cpp

@@ -1,28 +1,36 @@
 #include "rwSpiCallback.h"
-#include "devices/gpioIds.h"
-#include "mission/devices/RwHandler.h"
 
-#include "fsfw_hal/linux/spi/SpiCookie.h"
-#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "devices/gpioIds.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+#include "mission/devices/RwHandler.h"
 
 namespace rwSpiCallback {
 
 ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
                           size_t sendLen, void* args) {
-
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
   RwHandler* handler = reinterpret_cast<RwHandler*>(args);
   if (handler == nullptr) {
-        sif::error << "rwSpiCallback::spiCallback: Pointer to handler is invalid"
-                << std::endl;
+    sif::error << "rwSpiCallback::spiCallback: Pointer to handler is invalid" << std::endl;
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 
   uint8_t writeBuffer[2];
   uint8_t writeSize = 0;
 
+  gpioId_t gpioId = cookie->getChipSelectPin();
+  GpioIF* gpioIF = comIf->getGpioInterface();
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 0;
+  MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
+  if (mutex == nullptr or gpioIF == nullptr) {
+    sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
   int fileDescriptor = 0;
   std::string device = cookie->getSpiDevice();
   UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
@@ -35,27 +43,12 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
   cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
   comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
 
-    gpioId_t gpioId = cookie->getChipSelectPin();
-    GpioIF* gpioIF =  comIf->getGpioInterface();
-    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
-    uint32_t timeoutMs = 0;
-    MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
-    if(mutex == nullptr or gpioIF == nullptr) {
-        sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-
   result = mutex->lockMutex(timeoutType, timeoutMs);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
     return result;
   }
 
-    /** Disconnect PS SPI peripheral and select AXI SPI core */
-    if(gpioIF->pullHigh(gpioIds::SPI_MUX) != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "rwSpiCallback::spiCallback: Failed to pull spi mux gpio high" << std::endl;
-    }
-
   /** Sending frame start sign */
   writeBuffer[0] = 0x7E;
   writeSize = 1;
@@ -119,7 +112,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
 
   size_t replyBufferSize = cookie->getMaxBufferSize();
 
-    /** There must be a delay of 20 ms after sending the command */
+  /** There must be a delay of at least 20 ms after sending the command */
   usleep(RwDefinitions::SPI_REPLY_DELAY);
 
   /**
@@ -133,8 +126,15 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
       closeSpi(gpioId, gpioIF, mutex);
       return RwHandler::SPI_READ_FAILURE;
     }
+    if (idx == 0) {
+      if (byteRead != FLAG_BYTE) {
+        sif::error << "Invalid data, expected start marker" << std::endl;
+        closeSpi(gpioId, gpioIF, mutex);
+        return RwHandler::NO_START_MARKER;
+      }
+    }
 
-        if (byteRead != 0x7E) {
+    if (byteRead != FLAG_BYTE) {
       break;
     }
 
@@ -145,9 +145,12 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
     }
   }
 
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+  sif::info << "RW start marker detected" << std::endl;
+#endif
+
   size_t decodedFrameLen = 0;
   while (decodedFrameLen < replyBufferSize) {
-
     /** First byte already read in */
     if (decodedFrameLen != 0) {
       byteRead = 0;
@@ -158,11 +161,10 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
       }
     }
 
-        if (byteRead == 0x7E) {
+    if (byteRead == FLAG_BYTE) {
       /** Reached end of frame */
       break;
-        }
-        else if (byteRead == 0x7D) {
+    } else if (byteRead == 0x7D) {
       if (read(fileDescriptor, &byteRead, 1) != 1) {
         sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
         result = RwHandler::SPI_READ_FAILURE;
@@ -172,20 +174,17 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
         *(rxBuf + decodedFrameLen) = 0x7E;
         decodedFrameLen++;
         continue;
-            }
-            else if (byteRead == 0x5D) {
+      } else if (byteRead == 0x5D) {
         *(rxBuf + decodedFrameLen) = 0x7D;
         decodedFrameLen++;
         continue;
-            }
-            else {
+      } else {
         sif::error << "rwSpiCallback::spiCallback: Invalid substitute" << std::endl;
         closeSpi(gpioId, gpioIF, mutex);
         result = RwHandler::INVALID_SUBSTITUTE;
         break;
       }
-        }
-        else {
+    } else {
       *(rxBuf + decodedFrameLen) = byteRead;
       decodedFrameLen++;
       continue;
@@ -226,12 +225,8 @@ void closeSpi (gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
     }
   }
   if (mutex->unlockMutex() != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;;
-    }
-
-    /** Route SPI interface again to PS SPI peripheral */
-    if(gpioIF->pullLow(gpioIds::SPI_MUX) != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "rwSpiCallback::spiCallback: Failed to pull spi mux gpio low" << std::endl;
-    }
+    sif::error << "rwSpiCallback::closeSpi: Failed to unlock mutex" << std::endl;
+    ;
   }
 }
+}  // namespace rwSpiCallback

bsp_q7s/callbacks/rwSpiCallback.h

@@ -2,12 +2,14 @@
 #define BSP_Q7S_RW_SPI_CALLBACK_H_
 
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw_hal/linux/spi/SpiComIF.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
-
+#include "fsfw_hal/linux/spi/SpiComIF.h"
 
 namespace rwSpiCallback {
 
+//! This is the end and start marker of the frame datalinklayer
+static constexpr uint8_t FLAG_BYTE = 0x7E;
+
 /**
  * @brief   This is the callback function to send commands to the nano avionics reaction wheels and
  *          receive the replies.
@@ -40,5 +42,5 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie *cookie, const uint8_t *sen
  */
 void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
 
-}
+}  // namespace rwSpiCallback
 #endif /* BSP_Q7S_RW_SPI_CALLBACK_H_ */

bsp_q7s/comIF/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 )
 
 

bsp_q7s/core/CMakeLists.txt

@@ -1,6 +1,10 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
     CoreController.cpp
     obsw.cpp
     InitMission.cpp
     ObjectFactory.cpp
 )
+
+target_sources(${SIMPLE_OBSW_NAME} PRIVATE
+    InitMission.cpp
+)

bsp_q7s/core/CoreController.h

@@ -2,47 +2,83 @@
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
-#include "fsfw/controller/ExtendedControllerBase.h"
+#include <libxiphos.h>
+
+#include <cstddef>
+
 #include "bsp_q7s/memory/SdCardManager.h"
-
 #include "events/subsystemIdRanges.h"
-
+#include "fsfw/controller/ExtendedControllerBase.h"
 
 class Timer;
 class SdCardManager;
 
-class CoreController: public ExtendedControllerBase {
-public:
-    enum Chip: uint8_t {
-        CHIP_0,
-        CHIP_1,
-        NO_CHIP,
-        SELF_CHIP,
-        ALL_CHIP
+namespace xsc {
+
+enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
+enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
+
+}  // namespace xsc
+
+struct RebootFile {
+  static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
+
+  bool enabled = true;
+  size_t maxCount = DEFAULT_MAX_BOOT_CNT;
+  uint32_t img00Cnt = 0;
+  uint32_t img01Cnt = 0;
+  uint32_t img10Cnt = 0;
+  uint32_t img11Cnt = 0;
+  bool img00Lock = false;
+  bool img01Lock = false;
+  bool img10Lock = false;
+  bool img11Lock = false;
+  uint32_t* relevantBootCnt = &img00Cnt;
+  bool bootFlag = false;
+  xsc::Chip lastChip = xsc::Chip::CHIP_0;
+  xsc::Copy lastCopy = xsc::Copy::COPY_0;
+  xsc::Chip mechanismNextChip = xsc::Chip::NO_CHIP;
+  xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
-    enum Copy: uint8_t {
-        COPY_0,
-        COPY_1,
-        NO_COPY,
-        SELF_COPY,
-        ALL_COPY
-    };
+class CoreController : public ExtendedControllerBase {
+ public:
+  static xsc::Chip CURRENT_CHIP;
+  static xsc::Copy CURRENT_COPY;
 
   static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
   static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
   static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
-    static constexpr char VERSION_FILE[] = "/conf/sd_status";
+  static constexpr char CONF_FOLDER[] = "conf";
+  static constexpr char VERSION_FILE_NAME[] = "version.txt";
+  static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
+  const std::string VERSION_FILE =
+      "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
+  const std::string REBOOT_FILE =
+      "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
 
   static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
+  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
+  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
+  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
+  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
+
   static constexpr ActionId_t REBOOT_OBC = 32;
   static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
 
-
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
   static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
-
+  //! [EXPORT] : [COMMENT]  Software reboot occured. Can also be a systemd reboot.
+  //! P1: Current Chip, P2: Current Copy
+  static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
+  //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
+  //! P2: Each byte is the respective reboot count for the slots
+  static constexpr Event REBOOT_MECHANISM_TRIGGERED =
+      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
+  //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
+  static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
 
   CoreController(object_id_t objectId);
   virtual ~CoreController();
@@ -51,8 +87,8 @@ public:
 
   ReturnValue_t initializeAfterTaskCreation() override;
 
-    ReturnValue_t executeAction(ActionId_t actionId,
-            MessageQueueId_t commandedBy, const uint8_t *data, size_t size) override;
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
 
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
@@ -63,7 +99,7 @@ public:
    */
   static ReturnValue_t generateChipStateFile();
   static ReturnValue_t incrementAllocationFailureCount();
-    static void getCurrentBootCopy(Chip& chip, Copy& copy);
+  static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
 
   ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
 
@@ -78,15 +114,12 @@ public:
    * @param updateProtFile Specify whether the protection info file is updated
    * @return
    */
-    ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy,
-            bool protect, bool& protOperationPerformed, bool updateProtFile = true);
+  ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
+                                      bool& protOperationPerformed, bool updateProtFile = true);
 
   bool sdInitFinished() const;
 
  private:
-    static Chip CURRENT_CHIP;
-    static Copy CURRENT_COPY;
-
   // Designated value for rechecking FIFO open
   static constexpr int RETRY_FIFO_OPEN = -2;
   int watchdogFifoFd = 0;
@@ -135,8 +168,9 @@ private:
     sd::SdState currentlyCommandedState = sd::SdState::OFF;
     sd::SdCard commandedCard = sd::SdCard::NONE;
     sd::SdState commandedState = sd::SdState::OFF;
-    };
-    SdInfo sdInfo;
+  } sdInfo;
+  RebootFile rebootFile = {};
+  bool doPerformMountedSdCardOps = true;
 
   /**
    * Index 0: Chip 0 Copy 0
@@ -150,9 +184,8 @@ private:
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-    ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-                uint32_t *msToReachTheMode);
-
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
+  void performMountedSdCardOperations();
   ReturnValue_t initVersionFile();
   ReturnValue_t initBootCopy();
   ReturnValue_t initWatchdogFifo();
@@ -164,10 +197,12 @@ private:
   ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                             bool printOutput = true);
   ReturnValue_t sdColdRedundantBlockingInit();
+
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
   void determinePreferredSdCard();
   void executeNextExternalSdCommand();
   void checkExternalSdCommandStatus();
+  void performRebootFileHandling(bool recreateFile);
 
   ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
                                             const uint8_t* data, size_t size);
@@ -176,9 +211,15 @@ private:
   void performWatchdogControlOperation();
 
   ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
-    int handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
-            bool &protOperationPerformed, bool selfChip, bool selfCopy, bool allChips,
-            bool allCopies, uint8_t arrIdx);
+  int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
+                                bool& protOperationPerformed, bool selfChip, bool selfCopy,
+                                bool allChips, bool allCopies, uint8_t arrIdx);
+  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                                 xsc::Copy& tgtCopy);
+  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  bool parseRebootFile(std::string path, RebootFile& file);
+  void rewriteRebootFile(RebootFile file);
 };
 
 #endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */

bsp_q7s/core/InitMission.cpp

@@ -1,28 +1,27 @@
 #include "InitMission.h"
-#include "ObjectFactory.h"
-#include "OBSWConfig.h"
-#include "pollingsequence/pollingSequenceFactory.h"
-
-#include "mission/utility/InitMission.h"
-
-#include "fsfw/platform.h"
-#include "fsfw/objectmanager/ObjectManagerIF.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/tasks/FixedTimeslotTaskIF.h"
-#include "fsfw/tasks/PeriodicTaskIF.h"
-#include "fsfw/tasks/TaskFactory.h"
 
 #include <iostream>
 #include <vector>
 
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/platform.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+#include "fsfw/tasks/FixedTimeslotTaskIF.h"
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "mission/utility/InitMission.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
 ServiceInterfaceStream sif::debug("DEBUG");
 ServiceInterfaceStream sif::info("INFO");
 ServiceInterfaceStream sif::warning("WARNING");
-ServiceInterfaceStream sif::error("ERROR", false, false, true);
+ServiceInterfaceStream sif::error("ERROR");
 #else
 ServiceInterfaceStream sif::debug("DEBUG", true);
 ServiceInterfaceStream sif::info("INFO", true);
@@ -33,7 +32,6 @@ ServiceInterfaceStream sif::error("ERROR", true, false, true);
 ObjectManagerIF* objectManager = nullptr;
 
 void initmission::initMission() {
-
   sif::info << "Building global objects.." << std::endl;
   /* Instantiate global object manager and also create all objects */
   ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
@@ -82,19 +80,49 @@ void initmission::initTasks() {
     initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
   }
 
-    /* UDP bridge */
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  // TMTC bridge
   PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
-            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+      "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-        initmission::printAddObjectError("UDP_BRIDGE", objects::TMTC_BRIDGE);
+    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
   }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
-            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("UDP_POLLING", objects::TMTC_POLLING_TASK);
   }
+#endif
+
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
+      "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("CCSDS Handler", objects::CCSDS_HANDLER);
+  }
+
+  // Minimal distance between two received TCs amounts to 0.6 seconds
+  // If a command has not been read before the next one arrives, the old command will be
+  // overwritten by the PDEC.
+  PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
+      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+  result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
+  }
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+
+#if OBSW_ADD_ACS_HANDLERS == 1
+  PeriodicTaskIF* acsCtrl = factory->createPeriodicTask(
+      "ACS_CTRL", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = acsCtrl->addComponent(objects::GPS_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("ACS_CTRL", objects::GPS_CONTROLLER);
+  }
+#endif /* OBSW_ADD_ACS_HANDLERS */
 
 #if BOARD_TE0720 == 0
   // FS task, task interval does not matter because it runs in permanent loop, priority low
@@ -105,6 +133,16 @@ void initmission::initTasks() {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
   }
+
+#if OBSW_ADD_STAR_TRACKER == 1
+  PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
+      "STR_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = strHelperTask->addComponent(objects::STR_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("STR_HELPER", objects::STR_HELPER);
+  }
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+
 #endif /* BOARD_TE0720 */
 
 #if OBSW_TEST_CCSDS_BRIDGE == 1
@@ -130,8 +168,7 @@ void initmission::initTasks() {
     for (const auto& task : taskVector) {
       if (task != nullptr) {
         task->startTask();
-            }
-            else {
+      } else {
         sif::error << "Task in vector " << name << " is invalid!" << std::endl;
       }
     }
@@ -139,8 +176,17 @@ void initmission::initTasks() {
 
   sif::info << "Starting tasks.." << std::endl;
   tmTcDistributor->startTask();
+
+#if OBSW_ADD_TCPIP_BRIDGE == 1
   tmtcBridgeTask->startTask();
   tmtcPollingTask->startTask();
+#endif
+
+#if OBSW_USE_CCSDS_IP_CORE == 1
+  ccsdsHandlerTask->startTask();
+  pdecHandlerTask->startTask();
+#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+
 #if BOARD_TE0720 == 0
   coreController->startTask();
 #endif
@@ -157,47 +203,61 @@ void initmission::initTasks() {
 
 #if BOARD_TE0720 == 0
   fsTask->startTask();
+#if OBSW_ADD_STAR_TRACKER == 1
+  strHelperTask > startTask();
+#endif /* OBSW_ADD_STAR_TRACKER == 1 */
+#endif
+
+#if OBSW_ADD_ACS_HANDLERS == 1
+  acsCtrl->startTask();
 #endif
 
   sif::info << "Tasks started.." << std::endl;
 }
 
 void initmission::createPstTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*> &taskVec) {
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 #if BOARD_TE0720 == 0
   /* Polling Sequence Table Default */
 #if OBSW_ADD_SPI_TEST_CODE == 0
   FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
-            "PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
-            missedDeadlineFunc);
+      "PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
     }
+  } else {
     taskVec.push_back(spiPst);
+  }
 #endif
 
   FixedTimeslotTaskIF* uartPst = factory.createFixedTimeslotTask(
-            "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+      "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstUart(uartPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
   taskVec.push_back(uartPst);
   FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
-            "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+      "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstGpio(gpioPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
   taskVec.push_back(gpioPst);
+
+#if OBSW_ADD_I2C_TEST_CODE == 0
   FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
-            "I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+      "I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstI2c(i2cPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
   }
+  taskVec.push_back(i2cPst);
+#endif
 
   FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
       "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
@@ -208,8 +268,7 @@ void initmission::createPstTasks(TaskFactory& factory,
   taskVec.push_back(gomSpacePstTask);
 #else  /* BOARD_TE7020 == 0 */
   FixedTimeslotTaskIF* pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask(
-            "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0,
-            missedDeadlineFunc);
+      "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0, missedDeadlineFunc);
   result = pst::pollingSequenceTE0720(pollingSequenceTaskTE0720);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl;
@@ -219,7 +278,8 @@ void initmission::createPstTasks(TaskFactory& factory,
 }
 
 void initmission::createPusTasks(TaskFactory& factory,
-        TaskDeadlineMissedFunction missedDeadlineFunc, std::vector<PeriodicTaskIF*> &taskVec) {
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   /* PUS Services */
   PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
@@ -287,19 +347,20 @@ void initmission::createPusTasks(TaskFactory &factory,
   taskVec.push_back(pusLowPrio);
 }
 
-void initmission::createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+void initmission::createTestTasks(TaskFactory& factory,
+                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                   std::vector<PeriodicTaskIF*>& taskVec) {
-#if OBSW_ADD_TEST_TASK == 1 || OBSW_ADD_SPI_TEST_CODE == 1 || (BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1)
+#if OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-#endif
+  static_cast<void>(result);  // supress warning in case it is not used
+
   PeriodicTaskIF* testTask = factory.createPeriodicTask(
       "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
-#if OBSW_ADD_TEST_TASK == 1
+
   result = testTask->addComponent(objects::TEST_TASK);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
   }
-#endif /* OBSW_ADD_TEST_TASK == 1 */
 
 #if OBSW_ADD_SPI_TEST_CODE == 1
   result = testTask->addComponent(objects::SPI_TEST);
@@ -307,6 +368,19 @@ void initmission::createTestTasks(TaskFactory& factory, TaskDeadlineMissedFuncti
     initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
   }
 #endif
+#if OBSW_ADD_I2C_TEST_CODE == 1
+  result = testTask->addComponent(objects::I2C_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("I2C_TEST", objects::I2C_TEST);
+  }
+#endif
+#if OBSW_ADD_UART_TEST_CODE == 1
+  result = testTask->addComponent(objects::UART_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
+  }
+#endif
+
 #if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
   result = testTask->addComponent(objects::LIBGPIOD_TEST);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -314,4 +388,6 @@ void initmission::createTestTasks(TaskFactory& factory, TaskDeadlineMissedFuncti
   }
 #endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */
   taskVec.push_back(testTask);
+
+#endif  // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
 }

bsp_q7s/core/InitMission.h

@@ -1,9 +1,10 @@
 #ifndef BSP_Q7S_INITMISSION_H_
 #define BSP_Q7S_INITMISSION_H_
 
-#include "fsfw/tasks/Typedef.h"
 #include <vector>
 
+#include "fsfw/tasks/Typedef.h"
+
 class PeriodicTaskIF;
 class TaskFactory;
 
@@ -17,6 +18,6 @@ void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadl
                     std::vector<PeriodicTaskIF*>& taskVec);
 void createTestTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
                      std::vector<PeriodicTaskIF*>& taskVec);
-};
+};  // namespace initmission
 
 #endif /* BSP_Q7S_INITMISSION_H_ */

bsp_q7s/core/ObjectFactory.h

@@ -4,6 +4,7 @@
 class LinuxLibgpioIF;
 class UartComIF;
 class SpiComIF;
+class I2cComIF;
 
 namespace ObjectFactory {
 
@@ -11,9 +12,11 @@ void setStatics();
 void produce(void* args);
 
 void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
-        SpiComIF** spiComIF);
+                                   SpiComIF** spiComIF, I2cComIF** i2cComIF);
+
+void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
 void createTmpComponents();
-void createPcduComponents();
+void createPcduComponents(LinuxLibgpioIF* gpioComIF);
 void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
 void createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
 void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF);
@@ -22,8 +25,9 @@ void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents();
 void createRtdComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
+void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
 void createTestComponents(LinuxLibgpioIF* gpioComIF);
 
-};
+};  // namespace ObjectFactory
 
 #endif /* BSP_Q7S_OBJECTFACTORY_H_ */

bsp_q7s/core/ParameterHandler.cpp

@@ -1,8 +1,5 @@
 #include "ParameterHandler.h"
 
-ParameterHandler::ParameterHandler(std::string mountPrefix): mountPrefix(mountPrefix) {
-}
+ParameterHandler::ParameterHandler(std::string mountPrefix) : mountPrefix(mountPrefix) {}
 
-void ParameterHandler::setMountPrefix(std::string prefix) {
-    mountPrefix = prefix;
-}
+void ParameterHandler::setMountPrefix(std::string prefix) { mountPrefix = prefix; }

bsp_q7s/core/ParameterHandler.h

@@ -4,8 +4,6 @@
 #include <nlohmann/json.hpp>
 #include <string>
 
-
-
 class ParameterHandler {
  public:
   ParameterHandler(std::string mountPrefix);
@@ -13,10 +11,10 @@ public:
   void setMountPrefix(std::string prefix);
 
   void setUpDummyParameter();
+
  private:
   std::string mountPrefix;
   DummyParameter dummyParam;
 };
 
-
 #endif /* BSP_Q7S_CORE_PARAMETERHANDLER_H_ */

bsp_q7s/core/obsw.cpp

@@ -1,14 +1,14 @@
 #include "obsw.h"
-#include "OBSWVersion.h"
-#include "OBSWConfig.h"
-#include "InitMission.h"
-#include "watchdogConf.h"
 
-#include "fsfw/tasks/TaskFactory.h"
-#include "fsfw/FSFWVersion.h"
-
-#include <iostream>
 #include <filesystem>
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/FSFWVersion.h"
+#include "fsfw/tasks/TaskFactory.h"
+#include "watchdogConf.h"
 
 static int OBSW_ALREADY_RUNNING = -2;
 
@@ -19,17 +19,18 @@ int obsw::obsw() {
 #else
   std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;
 #endif
-    std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION <<
-            "." << SW_REVISION << ", FSFW v" << FSFW_VERSION << "." << FSFW_SUBVERSION << "." <<
-            FSFW_REVISION << "--"  << std::endl;
+  std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION << "." << SW_REVISION << ", FSFW v"
+            << FSFW_VERSION << "." << FSFW_SUBVERSION << "." << FSFW_REVISION << "--" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
 #if Q7S_CHECK_FOR_ALREADY_RUNNING_IMG == 1
   // Check special file here. This file is created or deleted by the eive-watchdog application
   // or systemd service!
   if (std::filesystem::exists(watchdog::RUNNING_FILE_NAME)) {
-        sif::warning << "File " << watchdog::RUNNING_FILE_NAME << " exists so the software might "
-                "already be running. Aborting.." << std::endl;
+    sif::warning << "File " << watchdog::RUNNING_FILE_NAME
+                 << " exists so the software might "
+                    "already be running. Check if obsw systemd service has been stopped."
+                 << std::endl;
     return OBSW_ALREADY_RUNNING;
   }
 #endif

bsp_q7s/devices/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
     PlocSupervisorHandler.cpp
     PlocUpdater.cpp
     PlocMemoryDumper.cpp

bsp_q7s/devices/PlocMemoryDumper.cpp

@@ -1,21 +1,23 @@
-#include <fsfw/src/fsfw/serialize/SerializeAdapter.h>
-#include "fsfw/ipc/QueueFactory.h"
 #include "PlocMemoryDumper.h"
 
-#include <fstream>
+#include <fsfw/src/fsfw/serialize/SerializeAdapter.h>
+
 #include <filesystem>
+#include <fstream>
 #include <string>
 
-PlocMemoryDumper::PlocMemoryDumper(object_id_t objectId) :
-        SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
-    commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
+#include "fsfw/ipc/QueueFactory.h"
+
+PlocMemoryDumper::PlocMemoryDumper(object_id_t objectId)
+    : SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
+  auto mqArgs = MqArgs(this->getObjectId());
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-PlocMemoryDumper::~PlocMemoryDumper() {
-}
+PlocMemoryDumper::~PlocMemoryDumper() {}
 
 ReturnValue_t PlocMemoryDumper::initialize() {
-
   ReturnValue_t result = SystemObject::initialize();
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
@@ -38,9 +40,8 @@ ReturnValue_t PlocMemoryDumper::performOperation(uint8_t operationCode) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId,
-        MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
-
+ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                              const uint8_t* data, size_t size) {
   if (state != State::IDLE) {
     return IS_BUSY;
   }
@@ -71,13 +72,9 @@ ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId,
   return EXECUTION_FINISHED;
 }
 
-MessageQueueId_t PlocMemoryDumper::getCommandQueue() const {
-    return commandQueue->getId();
-}
+MessageQueueId_t PlocMemoryDumper::getCommandQueue() const { return commandQueue->getId(); }
 
-MessageQueueIF* PlocMemoryDumper::getCommandQueuePtr() {
-    return commandQueue;
-}
+MessageQueueIF* PlocMemoryDumper::getCommandQueuePtr() { return commandQueue; }
 
 void PlocMemoryDumper::readCommandQueue() {
   CommandMessage message;
@@ -121,17 +118,12 @@ void PlocMemoryDumper::doStateMachine() {
   }
 }
 
-void PlocMemoryDumper::stepSuccessfulReceived(ActionId_t actionId,
-        uint8_t step) {
-}
+void PlocMemoryDumper::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
 
 void PlocMemoryDumper::stepFailedReceived(ActionId_t actionId, uint8_t step,
-        ReturnValue_t returnCode) {
-}
+                                          ReturnValue_t returnCode) {}
 
-void PlocMemoryDumper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
-
-}
+void PlocMemoryDumper::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
 
 void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
   switch (pendingCommand) {
@@ -140,8 +132,7 @@ void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
       if (mram.endAddress == mram.startAddress) {
         triggerEvent(MRAM_DUMP_FINISHED);
         state = State::IDLE;
-        }
-        else {
+      } else {
         state = State::COMMAND_CONSECUTIVE_MRAM_DUMP;
       }
       break;
@@ -153,8 +144,7 @@ void PlocMemoryDumper::completionSuccessfulReceived(ActionId_t actionId) {
   }
 }
 
-void PlocMemoryDumper::completionFailedReceived(ActionId_t actionId,
-        ReturnValue_t returnCode) {
+void PlocMemoryDumper::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
   switch (pendingCommand) {
     case (PLOC_SPV::FIRST_MRAM_DUMP):
     case (PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
@@ -179,8 +169,7 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
     tempEndAddress = mram.startAddress + MAX_MRAM_DUMP_SIZE;
     mram.startAddress += MAX_MRAM_DUMP_SIZE;
     mram.lastStartAddress = tempStartAddress;
-    }
-    else {
+  } else {
     tempStartAddress = mram.startAddress;
     tempEndAddress = mram.endAddress;
     mram.startAddress = mram.endAddress;
@@ -188,8 +177,8 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
 
   MemoryParams params(tempStartAddress, tempEndAddress);
 
-    result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            dumpCommand, &params);
+  result =
+      commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, dumpCommand, &params);
   if (result != RETURN_OK) {
     sif::warning << "PlocMemoryDumper::commandNextMramDump: Failed to send mram dump command "
                  << "with start address " << tempStartAddress << " and end address "
@@ -203,4 +192,3 @@ void PlocMemoryDumper::commandNextMramDump(ActionId_t dumpCommand) {
   pendingCommand = dumpCommand;
   return;
 }
-

bsp_q7s/devices/PlocMemoryDumper.h

@@ -3,18 +3,18 @@
 
 #include <bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h>
 #include <bsp_q7s/devices/devicedefinitions/PlocSupervisorDefinitions.h>
+
 #include "OBSWConfig.h"
-#include "fsfw/action/CommandActionHelper.h"
+#include "bsp_q7s/memory/SdCardManager.h"
 #include "fsfw/action/ActionHelper.h"
-#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "bsp_q7s/memory/SdCardManager.h"
-#include "linux/fsfwconfig/objects/systemObjectList.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
-
+#include "linux/fsfwconfig/objects/systemObjectList.h"
 
 /**
  * @brief   Because the buffer of the linux tty driver is limited to 2 x 65535 bytes, this class is
@@ -30,7 +30,6 @@ class PlocMemoryDumper : public SystemObject,
                          public HasReturnvaluesIF,
                          public CommandsActionsIF {
  public:
-
   static const ActionId_t NONE = 0;
   static const ActionId_t DUMP_MRAM = 1;
 
@@ -50,12 +49,12 @@ public:
   void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
 
  private:
-
   static const uint32_t QUEUE_SIZE = 10;
 
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MEMORY_DUMPER;
 
-    //! [EXPORT] : [COMMENT] The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.
+  //! [EXPORT] : [COMMENT] The capacity of the MRAM amounts to 512 kB. Thus the maximum address must
+  //! not be higher than 0x7d000.
   static const ReturnValue_t MRAM_ADDRESS_TOO_HIGH = MAKE_RETURN_CODE(0xA0);
   //! [EXPORT] : [COMMENT] The specified end address is lower than the start address
   static const ReturnValue_t MRAM_INVALID_ADDRESS_COMBINATION = MAKE_RETURN_CODE(0xA1);

bsp_q7s/devices/PlocSupervisorHandler.cpp

@@ -1,26 +1,28 @@
-#include <sstream>
-#include <string>
-#include <fstream>
-#include <filesystem>
-
 #include "PlocSupervisorHandler.h"
-#include "OBSWConfig.h"
 
-#include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/timemanager/Clock.h>
 
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+#include "OBSWConfig.h"
+
 PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
-        CookieIF * comCookie) :
-        DeviceHandlerBase(objectId, uartComIFid, comCookie), hkset(this), bootStatusReport(this), latchupStatusReport(
-                this) {
+                                             CookieIF* comCookie)
+    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
+      hkset(this),
+      bootStatusReport(this),
+      latchupStatusReport(this) {
   if (comCookie == NULL) {
     sif::error << "PlocSupervisorHandler: Invalid com cookie" << std::endl;
   }
 }
 
-PlocSupervisorHandler::~PlocSupervisorHandler() {
-}
+PlocSupervisorHandler::~PlocSupervisorHandler() {}
 
 ReturnValue_t PlocSupervisorHandler::initialize() {
   ReturnValue_t result = RETURN_OK;
@@ -41,7 +43,6 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
   return result;
 }
 
-
 void PlocSupervisorHandler::doStartUp() {
 #if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
   setMode(MODE_NORMAL);
@@ -50,22 +51,18 @@ void PlocSupervisorHandler::doStartUp(){
 #endif
 }
 
-void PlocSupervisorHandler::doShutDown(){
-    setMode(_MODE_POWER_DOWN);
-}
+void PlocSupervisorHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
 
-ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(
-		DeviceCommandId_t * id) {
+ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(
-		DeviceCommandId_t * id){
+ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(
-		DeviceCommandId_t deviceCommand, const uint8_t * commandData,
+ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                             const uint8_t* commandData,
                                                              size_t commandDataLen) {
   ReturnValue_t result = RETURN_FAILED;
   switch (deviceCommand) {
@@ -330,14 +327,12 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
                          PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
 }
 
-ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
-        size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) {
-
+ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
+                                                  DeviceCommandId_t* foundId, size_t* foundLen) {
   if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP) {
     *foundId = PLOC_SPV::FIRST_MRAM_DUMP;
     return parseMramPackets(start, remainingSize, foundLen);
-    }
-    else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
+  } else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
     *foundId = PLOC_SPV::CONSECUTIVE_MRAM_DUMP;
     return parseMramPackets(start, remainingSize, foundLen);
   }
@@ -387,7 +382,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
 
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                           const uint8_t* packet) {
-
   ReturnValue_t result = RETURN_OK;
 
   switch (id) {
@@ -416,7 +410,8 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     default: {
-        sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
+      sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id"
+                 << std::endl;
       return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
     }
   }
@@ -424,17 +419,12 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
   return result;
 }
 
-void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid(){
+void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
 
-}
-
-uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo){
-    return 500;
-}
+uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
 
 ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                              LocalDataPoolManager& poolManager) {
-
   localDataPoolMap.emplace(PLOC_SPV::NUM_TMS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(PLOC_SPV::TEMP_PS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(PLOC_SPV::TEMP_PL, new PoolEntry<uint32_t>({0}));
@@ -478,9 +468,9 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
 }
 
 ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
-                uint8_t expectedReplies, bool useAlternateId,
+                                                           uint8_t expectedReplies,
+                                                           bool useAlternateId,
                                                            DeviceCommandId_t alternateReplyID) {
-
   ReturnValue_t result = RETURN_OK;
 
   uint8_t enabledReplies = 0;
@@ -585,15 +575,15 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
    * Every command causes at least one acknowledgment and one execution report. Therefore both
    * replies will be enabled here.
    */
-    result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-            PLOC_SPV::ACK_REPORT);
+  result =
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::ACK_REPORT);
   if (result != RETURN_OK) {
     sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
                << PLOC_SPV::ACK_REPORT << " not in replyMap" << std::endl;
   }
 
-    result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-            PLOC_SPV::EXE_REPORT);
+  result =
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::EXE_REPORT);
   if (result != RETURN_OK) {
     sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
                << PLOC_SPV::EXE_REPORT << " not in replyMap" << std::endl;
@@ -603,7 +593,6 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
 }
 
 ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
-
   uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
 
   uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
@@ -616,7 +605,6 @@ ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t f
 }
 
 ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_ACK_REPORT);
@@ -635,7 +623,8 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
   switch (apid) {
     case PLOC_SPV::APID_ACK_FAILURE: {
       // TODO: Interpretation of status field in acknowledgment report
-       sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report" << std::endl;
+      sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report"
+                 << std::endl;
       DeviceCommandId_t commandId = getPendingCommand();
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(SUPV_ACK_FAILURE, commandId);
@@ -651,7 +640,8 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
       break;
     }
     default: {
-       sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
+      sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report"
+                 << std::endl;
       result = RETURN_FAILED;
       break;
     }
@@ -661,7 +651,6 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
 }
 
 ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_EXE_REPORT);
@@ -679,14 +668,15 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
     }
     case (PLOC_SPV::APID_EXE_FAILURE): {
       // TODO: Interpretation of status field in execution report
-        sif::error << "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
+      sif::error
+          << "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
           << std::endl;
       DeviceCommandId_t commandId = getPendingCommand();
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(SUPV_EXE_FAILURE, commandId);
-        }
-        else {
-            sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id" << std::endl;
+      } else {
+        sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id"
+                   << std::endl;
       }
       sendFailureReport(PLOC_SPV::EXE_REPORT, RECEIVED_EXE_FAILURE);
       disableExeReportReply();
@@ -706,43 +696,41 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
 }
 
 ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_HK_REPORT);
 
   if (result == CRC_FAILURE) {
-        sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc"
-                << std::endl;
+    sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
   }
 
   uint16_t offset = PLOC_SPV::DATA_FIELD_OFFSET;
-    hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                 *(data + offset + 3);
   offset += 4;
-    hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                 *(data + offset + 3);
   offset += 4;
-    hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                  *(data + offset + 3);
   offset += 4;
-    hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                 *(data + offset + 3);
   offset += 4;
-    hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                  *(data + offset + 3);
   offset += 4;
-    hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 |
+                        *(data + offset + 2) << 8 | *(data + offset + 3);
   offset += 4;
-    hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                 *(data + offset + 3);
   offset += 4;
-    hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                 *(data + offset + 3);
   offset += 4;
-    hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
-            | *(data + offset + 3);
+  hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
+                   *(data + offset + 3);
   offset += 4;
   hkset.nvm0_1_state = *(data + offset);
   offset += 1;
@@ -761,7 +749,8 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
   sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl;
-    sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap << std::endl;
+  sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap
+            << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: soc_state: " << hkset.socState << std::endl;
@@ -780,14 +769,14 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
 }
 
 ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_BOOT_STATUS_REPORT);
 
   if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
-                " crc" << std::endl;
+                  " crc"
+               << std::endl;
     return result;
   }
 
@@ -835,7 +824,6 @@ ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data)
 }
 
 ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
@@ -921,8 +909,8 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
             << latchupStatusReport.timeYear << std::endl;
   sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Msec: "
             << latchupStatusReport.timeMsec << std::endl;
-    sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x"
-            << std::hex << latchupStatusReport.timeMsec << std::dec << std::endl;
+  sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x" << std::hex
+            << latchupStatusReport.timeMsec << std::dec << std::endl;
 #endif
 
   return result;
@@ -953,15 +941,13 @@ void PlocSupervisorHandler::setNextReplyId() {
 }
 
 size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId) {
-
   size_t replyLen = 0;
 
   if (nextReplyId == PLOC_SPV::NONE) {
     return replyLen;
   }
 
-    if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP
-            || nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
+  if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP || nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
     /**
      * Try to read 20 MRAM packets. If reply is larger, the packets will be read with the
      * next doSendRead call. The command will be as long active as the packet with the sequence
@@ -978,8 +964,7 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
       return replyLen;
     }
     replyLen = iter->second.replyLen;
-    }
-    else {
+  } else {
     sif::debug << "PlocSupervisorHandler::getNextReplyLength: No entry for reply with reply id "
                << std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
   }
@@ -987,8 +972,8 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
   return replyLen;
 }
 
-void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId) {
-
+void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
+                                           DeviceCommandId_t replyId) {
   ReturnValue_t result = RETURN_OK;
 
   if (wiretappingMode == RAW) {
@@ -1043,8 +1028,8 @@ void PlocSupervisorHandler::prepareDisableHk() {
 }
 
 void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* commandData) {
-    uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
-            | *(commandData + 3);
+  uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
+                     *(commandData + 3);
   PLOC_SPV::SetBootTimeout packet(timeout);
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
@@ -1073,8 +1058,8 @@ ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint
   if (watchdog > 2) {
     return INVALID_WATCHDOG;
   }
-    uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+  uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
+                     *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (timeout < 1000 || timeout > 360000) {
     return INVALID_WATCHDOG_TIMEOUT;
   }
@@ -1115,8 +1100,8 @@ ReturnValue_t PlocSupervisorHandler::prepareAutoCalibrateAlertCmd(const uint8_t*
   uint8_t offset = 0;
   uint8_t latchupId = *commandData;
   offset += 1;
-    uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+  uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
+                *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (latchupId > 6) {
     return INVALID_LATCHUP_ID;
   }
@@ -1141,8 +1126,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
   uint8_t offset = 0;
   uint8_t latchupId = *commandData;
   offset += 1;
-    uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+  uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
+                       *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (latchupId > 6) {
     return INVALID_LATCHUP_ID;
   }
@@ -1152,8 +1137,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
 }
 
 ReturnValue_t PlocSupervisorHandler::prepareSetAdcSweetPeriodCmd(const uint8_t* commandData) {
-    uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16
-            | *(commandData + 2) << 8 | *(commandData + 3);
+  uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
+                         *(commandData + 3);
   if (sweepPeriod < 21) {
     return SWEEP_PERIOD_TOO_SMALL;
   }
@@ -1178,8 +1163,8 @@ void PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8_t* comma
 }
 
 void PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* commandData) {
-    uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
-            | *(commandData + 3);
+  uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
+                       *(commandData + 3);
   PLOC_SPV::SetAdcThreshold packet(threshold);
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
@@ -1275,7 +1260,6 @@ void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSi
 }
 
 void PlocSupervisorHandler::disableAllReplies() {
-
   DeviceReplyMap::iterator iter;
 
   /* Disable ack reply */
@@ -1305,7 +1289,6 @@ void PlocSupervisorHandler::disableAllReplies() {
 }
 
 void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
-
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
 
   if (iter == deviceReplyMap.end()) {
@@ -1316,7 +1299,8 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
   DeviceCommandInfo* info = &(iter->second.command->second);
 
   if (info == nullptr) {
-        sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command" << std::endl;
+    sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command"
+               << std::endl;
     return;
   }
 
@@ -1367,7 +1351,6 @@ ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t *packet, siz
 }
 
 ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) {
-
   ReturnValue_t result = RETURN_FAILED;
 
   // Prepare packet for downlink
@@ -1380,8 +1363,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
     }
     handleMramDumpFile(id);
     if (downlinkMramDump == true) {
-            handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1,
-                    id);
+      handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1, id);
     }
     packetInBuffer = false;
     receivedMramDumpPackets++;
@@ -1426,16 +1408,15 @@ void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
     return;
   }
   uint8_t sequenceFlags = spacePacketBuffer[2] >> 6;
-    if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT)
-            && (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
+  if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT) &&
+      (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
     // Command expects at least one MRAM packet more and the execution report
     info->expectedReplies = 2;
     // Wait maximum of 2 cycles for next MRAM packet
     mramReplyInfo->delayCycles = 2;
     // Also adapting delay cycles for execution report
     exeReplyInfo->delayCycles = 3;
-    }
-    else {
+  } else {
     // Command expects the execution report
     info->expectedReplies = 1;
     mramReplyInfo->delayCycles = 0;
@@ -1456,8 +1437,8 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
   uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
   uint8_t sequenceFlags = readSequenceFlags(spacePacketBuffer);
   if (id == PLOC_SPV::FIRST_MRAM_DUMP) {
-        if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT)
-                || (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
+    if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT) ||
+        (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
       result = createMramDumpFile();
       if (result != RETURN_OK) {
         return result;
@@ -1523,8 +1504,8 @@ ReturnValue_t PlocSupervisorHandler::getTimeStampString(std::string& timeStamp)
                  << std::endl;
     return GET_TIME_FAILURE;
   }
-    timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-"
-            + std::to_string(time.day) + "--" + std::to_string(time.hour) + "-"
-            + std::to_string(time.minute) + "-" + std::to_string(time.second);
+  timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-" +
+              std::to_string(time.day) + "--" + std::to_string(time.hour) + "-" +
+              std::to_string(time.minute) + "-" + std::to_string(time.second);
   return RETURN_OK;
 }

bsp_q7s/devices/PlocSupervisorHandler.h

@@ -1,12 +1,12 @@
 #ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 
-#include "devicedefinitions/PlocSupervisorDefinitions.h"
 #include <bsp_q7s/memory/SdCardManager.h>
-
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw_hal/linux/uart/UartComIF.h>
 
+#include "devicedefinitions/PlocSupervisorDefinitions.h"
+
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
  *          Thales.
@@ -21,7 +21,6 @@
  */
 class PlocSupervisorHandler : public DeviceHandlerBase {
  public:
-
   PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie);
   virtual ~PlocSupervisorHandler();
 
@@ -33,12 +32,11 @@ protected:
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
   void fillCommandAndReplyMap() override;
-	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-				const uint8_t * commandData,size_t commandDataLen) override;
-	ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
-			DeviceCommandId_t *foundId, size_t *foundLen) override;
-	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
-			const uint8_t *packet) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
+                             size_t* foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
   void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -49,7 +47,6 @@ protected:
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
  private:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPERVISOR_HANDLER;
 
   //! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC
@@ -64,25 +61,32 @@ private:
   static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4);
   //! [EXPORT] : [COMMENT] Invalid communication interface specified
   static const ReturnValue_t INVALID_UART_COM_IF = MAKE_RETURN_CODE(0xA5);
-    //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT
+  //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0
+  //! for PS, 1 for PL and 2 for INT
   static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA6);
-    //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.
+  //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid
+  //! timeouts must be in the range between 1000 and 360000 ms.
   static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA7);
   //! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID
   static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA8);
-    //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be larger than 21.
+  //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be
+  //! larger than 21.
   static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA9);
-    //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1 and 2.
+  //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1
+  //! and 2.
   static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xAA);
   //! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed.
   static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAB);
-    //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address)
+  //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM  wipe
+  //! commands are invalid (e.g. start address bigger than stop address)
   static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAC);
-    //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with other apid.
+  //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with
+  //! other apid.
   static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAD);
   //! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist
   static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAE);
-    //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.
+  //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have
+  //! been created with the reception of the first dump packet.
   static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAF);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
@@ -258,7 +262,6 @@ private:
   void prepareSetGpioCmd(const uint8_t* commandData);
   void prepareReadGpioCmd(const uint8_t* commandData);
 
-
   /**
    * @brief   Copies the content of a space packet to the command buffer.
    */

bsp_q7s/devices/PlocUpdater.cpp

@@ -1,17 +1,19 @@
-#include "fsfw/ipc/QueueFactory.h"
 #include "PlocUpdater.h"
 
-#include <fstream>
 #include <filesystem>
+#include <fstream>
 #include <string>
 
-PlocUpdater::PlocUpdater(object_id_t objectId) :
-        SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
-    commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
+#include "fsfw/ipc/QueueFactory.h"
+
+PlocUpdater::PlocUpdater(object_id_t objectId)
+    : SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
+  auto mqArgs = MqArgs(this->getObjectId());
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-PlocUpdater::~PlocUpdater() {
-}
+PlocUpdater::~PlocUpdater() {}
 
 ReturnValue_t PlocUpdater::initialize() {
 #if BOARD_TE0720 == 0
@@ -39,8 +41,8 @@ ReturnValue_t PlocUpdater::performOperation(uint8_t operationCode) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId,
-        MessageQueueId_t commandedBy, const uint8_t* data, size_t size) {
+ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                         const uint8_t* data, size_t size) {
   ReturnValue_t result = RETURN_FAILED;
 
   if (state != State::IDLE) {
@@ -99,13 +101,9 @@ ReturnValue_t PlocUpdater::executeAction(ActionId_t actionId,
   return EXECUTION_FINISHED;
 }
 
-MessageQueueId_t PlocUpdater::getCommandQueue() const {
-    return commandQueue->getId();
-}
+MessageQueueId_t PlocUpdater::getCommandQueue() const { return commandQueue->getId(); }
 
-MessageQueueIF* PlocUpdater::getCommandQueuePtr() {
-    return commandQueue;
-}
+MessageQueueIF* PlocUpdater::getCommandQueuePtr() { return commandQueue; }
 
 void PlocUpdater::readCommandQueue() {
   CommandMessage message;
@@ -167,19 +165,19 @@ ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) {
 
 #if BOARD_TE0720 == 0
   // Check if file is stored on SD card and if associated SD card is mounted
-    if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_0_MOUNT_POINT)) {
-        if (!isSdCardMounted(sd::SLOT_0)) {
-            sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 0 not mounted" << std::endl;
+  if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) ==
+      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+      sif::warning << "PlocUpdater::getImageLocation: SD card 0 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-    }
-    else if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) == std::string(SdCardManager::SD_1_MOUNT_POINT)) {
-        if (!isSdCardMounted(sd::SLOT_0)) {
-            sif::warning << "PlocUpdater::prepareNvm0AUpdate: SD card 1 not mounted" << std::endl;
+  } else if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) ==
+             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+      sif::warning << "PlocUpdater::getImageLocation: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-    }
-    else {
+  } else {
     // update image not stored on SD card
   }
 #endif /* BOARD_TE0720 == 0 */
@@ -193,48 +191,11 @@ ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) {
   return RETURN_OK;
 }
 
-#if BOARD_TE0720 == 0
-bool PlocUpdater::isSdCardMounted(sd::SdCard sdCard) {
-    SdCardManager::SdStatePair active;
-    ReturnValue_t result = sdcMan->getSdCardActiveStatus(active);
-    if (result != RETURN_OK) {
-        sif::debug << "PlocUpdater::isSdCardMounted: Failed to get SD card active state";
-        return false;
-    }
-    if (sdCard == sd::SLOT_0) {
-        if (active.first == sd::MOUNTED) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    else if (sdCard == sd::SLOT_1) {
-        if (active.second == sd::MOUNTED) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    else {
-        sif::debug << "PlocUpdater::isSdCardMounted: Unknown SD card specified" << std::endl;
-    }
-    return false;
-}
-#endif /* #if BOARD_TE0720 == 0 */
+void PlocUpdater::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
 
-void PlocUpdater::stepSuccessfulReceived(ActionId_t actionId,
-        uint8_t step) {
-}
+void PlocUpdater::stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) {}
 
-void PlocUpdater::stepFailedReceived(ActionId_t actionId, uint8_t step,
-        ReturnValue_t returnCode) {
-}
-
-void PlocUpdater::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
-
-}
+void PlocUpdater::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {}
 
 void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
   switch (pendingCommand) {
@@ -245,8 +206,7 @@ void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
       if (remainingPackets == 0) {
         packetsSent = 0;  // Reset packets sent variable for next update sequence
         state = State::UPDATE_VERIFY;
-        }
-        else {
+      } else {
         state = State::UPDATE_TRANSFER;
       }
       break;
@@ -263,8 +223,7 @@ void PlocUpdater::completionSuccessfulReceived(ActionId_t actionId) {
   }
 }
 
-void PlocUpdater::completionFailedReceived(ActionId_t actionId,
-        ReturnValue_t returnCode) {
+void PlocUpdater::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
   switch (pendingCommand) {
     case (PLOC_SPV::UPDATE_AVAILABLE): {
       triggerEvent(UPDATE_AVAILABLE_FAILED);
@@ -279,8 +238,7 @@ void PlocUpdater::completionFailedReceived(ActionId_t actionId,
       break;
     }
     default:
-        sif::debug << "PlocUpdater::completionFailedReceived: Invalid pending command "
-                << std::endl;
+      sif::debug << "PlocUpdater::completionFailedReceived: Invalid pending command " << std::endl;
       break;
   }
   state = State::IDLE;
@@ -311,10 +269,12 @@ void PlocUpdater::commandUpdateAvailable() {
   calcImageCrc();
 
   PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_AVAILABLE, static_cast<uint8_t>(image),
-            static_cast<uint8_t>(partition), imageSize, imageCrc, numOfUpdatePackets);
+                              static_cast<uint8_t>(partition), imageSize, imageCrc,
+                              numOfUpdatePackets);
 
   result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_AVAILABLE, packet.getWholeData(), packet.getFullSize());
+                                             PLOC_SPV::UPDATE_AVAILABLE, packet.getWholeData(),
+                                             packet.getFullSize());
   if (result != RETURN_OK) {
     sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
                  << " packet to supervisor handler" << std::endl;
@@ -344,8 +304,7 @@ void PlocUpdater::commandUpdatePacket() {
 
   if (remainingPackets == 1) {
     payloadLength = imageSize - static_cast<uint16_t>(file.tellg());
-    }
-    else {
+  } else {
     payloadLength = MAX_SP_DATA;
   }
 
@@ -360,7 +319,8 @@ void PlocUpdater::commandUpdatePacket() {
   packet.makeCrc();
 
   result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_IMAGE_DATA, packet.getWholeData(), packet.getFullSize());
+                                             PLOC_SPV::UPDATE_IMAGE_DATA, packet.getWholeData(),
+                                             packet.getFullSize());
 
   if (result != RETURN_OK) {
     sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update"
@@ -382,10 +342,12 @@ void PlocUpdater::commandUpdateVerify() {
   ReturnValue_t result = RETURN_OK;
 
   PLOC_SPV::UpdateInfo packet(PLOC_SPV::APID_UPDATE_VERIFY, static_cast<uint8_t>(image),
-            static_cast<uint8_t>(partition), imageSize, imageCrc, numOfUpdatePackets);
+                              static_cast<uint8_t>(partition), imageSize, imageCrc,
+                              numOfUpdatePackets);
 
-    result = commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER,
-            PLOC_SPV::UPDATE_VERIFY, packet.getWholeData(), packet.getFullSize());
+  result =
+      commandActionHelper.commandAction(objects::PLOC_SUPERVISOR_HANDLER, PLOC_SPV::UPDATE_VERIFY,
+                                        packet.getWholeData(), packet.getFullSize());
   if (result != RETURN_OK) {
     sif::warning << "PlocUpdater::commandUpdateAvailable: Failed to send update available"
                  << " packet to supervisor handler" << std::endl;
@@ -425,12 +387,9 @@ void PlocUpdater::calcImageCrc() {
 void PlocUpdater::adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet) {
   if (packetsSent == 0) {
     packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT));
-    }
-    else if (remainingPackets == 1) {
+  } else if (remainingPackets == 1) {
     packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT));
-    }
-    else {
+  } else {
     packet.setSequenceFlags(static_cast<uint8_t>(PLOC_SPV::SequenceFlags::CONTINUED_PKT));
   }
 }
-

bsp_q7s/devices/PlocUpdater.h

@@ -2,27 +2,25 @@
 #define MISSION_DEVICES_PLOCUPDATER_H_
 
 #include "OBSWConfig.h"
+#include "bsp_q7s/memory/SdCardManager.h"
 #include "devicedefinitions/PlocSupervisorDefinitions.h"
-
-#include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/ActionHelper.h"
-#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "bsp_q7s/memory/SdCardManager.h"
-#include "linux/fsfwconfig/objects/systemObjectList.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
-
+#include "linux/fsfwconfig/objects/systemObjectList.h"
 
 /**
  * @brief   An object of this class can be used to perform the software updates of the PLOC. The
  *          software update will be read from one of the SD cards, split into multiple space
  *          packets and sent to the PlocSupervisorHandler.
  *
- * @details The MPSoC has two boot memories (NVM0 and NVM1) where each stores two images (Partition A
- *          and Partition B)
+ * @details The MPSoC has two boot memories (NVM0 and NVM1) where each stores two images (Partition
+ * A and Partition B)
  *
  * @author  J. Meier
  */
@@ -32,7 +30,6 @@ class PlocUpdater : public SystemObject,
                     public HasReturnvaluesIF,
                     public CommandsActionsIF {
  public:
-
   static const ActionId_t UPDATE_A_UBOOT = 0;
   static const ActionId_t UPDATE_A_BITSTREAM = 1;
   static const ActionId_t UPDATE_A_LINUX = 2;
@@ -58,14 +55,14 @@ public:
   void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
 
  private:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_UPDATER;
 
   //! [EXPORT] : [COMMENT] Updater is already performing an update
   static const ReturnValue_t UPDATER_BUSY = MAKE_RETURN_CODE(0xA0);
   //! [EXPORT] : [COMMENT] Received update command with invalid path string (too long).
   static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA1);
-    //! [EXPORT] : [COMMENT] Received command to initiate update but SD card with update image not mounted.
+  //! [EXPORT] : [COMMENT] Received command to initiate update but SD card with update image not
+  //! mounted.
   static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA2);
   //! [EXPORT] : [COMMENT] Update file received with update command does not exist.
   static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA3);
@@ -74,13 +71,15 @@ private:
 
   //! [EXPORT] : [COMMENT] Try to read update file but the file does not exist.
   //! P1: Indicates in which state the file read fails
-    //! P2: During the update transfer the second parameter gives information about the number of already sent packets
+  //! P2: During the update transfer the second parameter gives information about the number of
+  //! already sent packets
   static const Event UPDATE_FILE_NOT_EXISTS = MAKE_EVENT(0, severity::LOW);
   //! [EXPORT] : [COMMENT] Failed to send command to supervisor handler
   //! P1: Return value of CommandActionHelper::commandAction
   //! P2: Action ID of command to send
   static const Event ACTION_COMMANDING_FAILED = MAKE_EVENT(1, severity::LOW);
-    //! [EXPORT] : [COMMENT] Supervisor handler replied action message indicating a command execution failure of the update available command
+  //! [EXPORT] : [COMMENT] Supervisor handler replied action message indicating a command execution
+  //! failure of the update available command
   static const Event UPDATE_AVAILABLE_FAILED = MAKE_EVENT(2, severity::LOW);
   //! [EXPORT] : [COMMENT] Supervisor handler failed to transfer an update space packet.
   //! P1: Parameter holds the number of update packets already sent (inclusive the failed packet)
@@ -122,21 +121,11 @@ private:
 
   ActionId_t pendingCommand = PLOC_SPV::NONE;
 
-    enum class Image: uint8_t {
-        NONE,
-        A,
-        B
-    };
+  enum class Image : uint8_t { NONE, A, B };
 
   Image image = Image::NONE;
 
-    enum class Partition: uint8_t {
-        NONE,
-        UBOOT,
-        BITSTREAM,
-        LINUX_OS,
-        APP_SW
-    };
+  enum class Partition : uint8_t { NONE, UBOOT, BITSTREAM, LINUX_OS, APP_SW };
 
   Partition partition = Partition::NONE;
 
@@ -174,13 +163,6 @@ private:
    */
   void commandUpdateVerify();
 
-#if BOARD_TE0720 == 0
-    /**
-     * @brief   Checks whether the SD card to read from is mounted or not.
-     */
-    bool isSdCardMounted(sd::SdCard sdCard);
-#endif
-
   void calcImageCrc();
 
   void adjustSequenceFlags(PLOC_SPV::UpdatePacket& packet);

bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h

@@ -5,18 +5,17 @@
 
 class MemoryParams : public SerialLinkedListAdapter<SerializeIF> {
  public:
-
   /**
    * @brief   Constructor
    * @param startAddress  Start of address range to dump
    * @param endAddress    End of address range to dump
    */
-    MemoryParams(uint32_t startAddress, uint32_t endAddress) :
-            startAddress(startAddress), endAddress(endAddress) {
+  MemoryParams(uint32_t startAddress, uint32_t endAddress)
+      : startAddress(startAddress), endAddress(endAddress) {
     setLinks();
   }
-private:
 
+ private:
   void setLinks() {
     setStart(&startAddress);
     startAddress.setNext(&endAddress);
@@ -24,10 +23,6 @@ private:
 
   SerializeElement<uint32_t> startAddress;
   SerializeElement<uint32_t> endAddress;
-
 };
 
-
-
-
 #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_PLOCMEMDUMPDEFINITIONS_H_ */

bsp_q7s/gpio/CMakeLists.txt

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

bsp_q7s/gpio/gpioCallbacks.cpp

@@ -1,340 +0,0 @@
-#include "gpioCallbacks.h"
-#include "busConf.h"
-#include <devices/gpioIds.h>
-
-#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
-#include <fsfw_hal/common/gpio/GpioCookie.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-
-
-namespace gpioCallbacks {
-
-GpioIF* gpioComInterface;
-
-void initSpiCsDecoder(GpioIF* gpioComIF) {
-
-    ReturnValue_t result;
-
-    if (gpioComIF == nullptr) {
-        sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
-        return;
-    }
-
-    gpioComInterface = gpioComIF;
-
-    GpioCookie* spiMuxGpios = new GpioCookie;
-
-    GpiodRegularByLabel* spiMuxBit = nullptr;
-    /** Setting mux bit 1 to low will disable IC21 on the interface board */
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_1,
-            "SPI Mux Bit 1", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
-    /** Setting mux bit 2 to low disables IC1 on the TCS board */
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_2,
-            "SPI Mux Bit 2", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
-    /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_3,
-            "SPI Mux Bit 3", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
-    /** The following gpios can take arbitrary initial values */
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_4,
-            "SPI Mux Bit 4", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_5,
-            "SPI Mux Bit 5", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
-    spiMuxBit = new GpiodRegularByLabel(q7s::GPIO_3V3_OBC1C, q7s::SPI_MUX_BIT_6,
-            "SPI Mux Bit 6", gpio::OUT, gpio::LOW);
-    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_6, spiMuxBit);
-    GpiodRegularByLabel* enRwDecoder = new GpiodRegularByLabel(q7s::GPIO_FLEX_OBC1F_B1,
-            q7s::EN_RW_CS, "EN_RW_CS", gpio::OUT, gpio::HIGH);
-    spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
-
-    result = gpioComInterface->addGpios(spiMuxGpios);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
-        return;
-    }
-}
-
-void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, int value,
-        void* args) {
-
-    if (gpioComInterface == nullptr) {
-        sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
-                << "to specify gpioComIF" << std::endl;
-        return;
-    }
-
-    /* Reading is not supported by the callback function */
-    if (gpioOp == gpio::GpioOperation::READ) {
-        return;
-    }
-
-    if (value == 1) {
-        disableAllDecoder();
-    }
-    else if (value == 0) {
-        switch (gpioId) {
-        case(gpioIds::RTD_IC3): {
-            enableDecoderTcsIc1();
-            selectY7();
-            break;
-        }
-        case(gpioIds::RTD_IC4): {
-            enableDecoderTcsIc1();
-            selectY6();
-            break;
-        }
-        case(gpioIds::RTD_IC5): {
-            enableDecoderTcsIc1();
-            selectY5();
-            break;
-        }
-        case(gpioIds::RTD_IC6): {
-            enableDecoderTcsIc1();
-            selectY4();
-            break;
-        }
-        case(gpioIds::RTD_IC7): {
-            enableDecoderTcsIc1();
-            selectY3();
-            break;
-        }
-        case(gpioIds::RTD_IC8): {
-            enableDecoderTcsIc1();
-            selectY2();
-            break;
-        }
-        case(gpioIds::RTD_IC9): {
-            enableDecoderTcsIc1();
-            selectY1();
-            break;
-        }
-        case(gpioIds::RTD_IC10): {
-            enableDecoderTcsIc1();
-            selectY0();
-            break;
-        }
-        case(gpioIds::RTD_IC11): {
-            enableDecoderTcsIc2();
-            selectY7();
-            break;
-        }
-        case(gpioIds::RTD_IC12): {
-            enableDecoderTcsIc2();
-            selectY6();
-            break;
-        }
-        case(gpioIds::RTD_IC13): {
-            enableDecoderTcsIc2();
-            selectY5();
-            break;
-        }
-        case(gpioIds::RTD_IC14): {
-            enableDecoderTcsIc2();
-            selectY4();
-            break;
-        }
-        case(gpioIds::RTD_IC15): {
-            enableDecoderTcsIc2();
-            selectY3();
-            break;
-        }
-        case(gpioIds::RTD_IC16): {
-            enableDecoderTcsIc2();
-            selectY2();
-            break;
-        }
-        case(gpioIds::RTD_IC17): {
-            enableDecoderTcsIc2();
-            selectY1();
-            break;
-        }
-        case(gpioIds::RTD_IC18): {
-            enableDecoderTcsIc2();
-            selectY0();
-            break;
-        }
-        case(gpioIds::CS_SUS_1): {
-            enableDecoderInterfaceBoardIc1();
-            selectY0();
-            break;
-        }
-        case(gpioIds::CS_SUS_2): {
-            enableDecoderInterfaceBoardIc1();
-            selectY1();
-            break;
-        }
-        case(gpioIds::CS_SUS_3): {
-            enableDecoderInterfaceBoardIc2();
-            selectY0();
-            break;
-        }
-        case(gpioIds::CS_SUS_4): {
-            enableDecoderInterfaceBoardIc2();
-            selectY1();
-            break;
-        }
-        case(gpioIds::CS_SUS_5): {
-            enableDecoderInterfaceBoardIc2();
-            selectY2();
-            break;
-        }
-        case(gpioIds::CS_SUS_6): {
-            enableDecoderInterfaceBoardIc1();
-            selectY2();
-            break;
-        }
-        case(gpioIds::CS_SUS_7): {
-            enableDecoderInterfaceBoardIc1();
-            selectY3();
-            break;
-        }
-        case(gpioIds::CS_SUS_8): {
-            enableDecoderInterfaceBoardIc2();
-            selectY3();
-            break;
-        }
-        case(gpioIds::CS_SUS_9): {
-            enableDecoderInterfaceBoardIc1();
-            selectY4();
-            break;
-        }
-        case(gpioIds::CS_SUS_10): {
-            enableDecoderInterfaceBoardIc1();
-            selectY5();
-            break;
-        }
-        case(gpioIds::CS_SUS_11): {
-            enableDecoderInterfaceBoardIc2();
-            selectY4();
-            break;
-        }
-        case(gpioIds::CS_SUS_12): {
-            enableDecoderInterfaceBoardIc2();
-            selectY5();
-            break;
-        }
-        case(gpioIds::CS_SUS_13): {
-            enableDecoderInterfaceBoardIc1();
-            selectY6();
-            break;
-        }
-        case(gpioIds::CS_RW1): {
-            enableRwDecoder();
-            selectY0();
-            break;
-        }
-        case(gpioIds::CS_RW2): {
-            enableRwDecoder();
-            selectY1();
-            break;
-        }
-        case(gpioIds::CS_RW3): {
-            enableRwDecoder();
-            selectY2();
-            break;
-        }
-        case(gpioIds::CS_RW4): {
-            enableRwDecoder();
-            selectY3();
-            break;
-        }
-        default:
-            sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
-        }
-    }
-    else {
-        sif::debug << "spiCsDecoderCallback: Invalid value. Must be 0 or 1" << std::endl;
-    }
-}
-
-void enableDecoderTcsIc1() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-}
-
-void enableDecoderTcsIc2() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-}
-
-void enableDecoderInterfaceBoardIc1() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-}
-
-void enableDecoderInterfaceBoardIc2() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-}
-
-void enableRwDecoder() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-    gpioComInterface->pullHigh(gpioIds::EN_RW_CS);
-}
-
-void selectY0() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY1() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY2() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY3() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY4() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY5() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY6() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
-}
-
-void selectY7() {
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-    gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
-}
-
-void disableAllDecoder() {
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-    gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-    gpioComInterface->pullLow(gpioIds::EN_RW_CS);
-}
-
-}

bsp_q7s/gpio/gpioCallbacks.h

@@ -1,67 +0,0 @@
-#ifndef LINUX_GPIO_GPIOCALLBACKS_H_
-#define LINUX_GPIO_GPIOCALLBACKS_H_
-
-#include <fsfw_hal/common/gpio/gpioDefinitions.h>
-#include <fsfw_hal/common/gpio/GpioIF.h>
-
-
-namespace gpioCallbacks {
-
-    /**
-     * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
-     *          the TCS Board and the interface board.
-     */
-    void initSpiCsDecoder(GpioIF* gpioComIF);
-
-    /**
-     * @brief   This function implements the decoding to multiply gpios by using the decoder
-     *          chips SN74LVC138APWR on the TCS board and the interface board.
-     */
-    void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args);
-
-    /**
-     * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
-     *          on the TCS board which is named to IC1 in the schematic.
-     */
-    void enableDecoderTcsIc1();
-
-    /**
-     * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
-     *          on the TCS board which is named to IC2 in the schematic.
-     */
-    void enableDecoderTcsIc2();
-
-    /**
-     * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
-     *          on the inteface board board which is named to IC21 in the schematic.
-     */
-    void enableDecoderInterfaceBoardIc1();
-
-    /**
-     * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
-     *          on the inteface board board which is named to IC22 in the schematic.
-     */
-    void enableDecoderInterfaceBoardIc2();
-
-    /**
-     * @brief   Enables the reaction wheel chip select decoder (IC3).
-     */
-    void enableRwDecoder();
-
-    /**
-     * @brief   This function disables all decoder.
-     */
-    void disableAllDecoder();
-
-    /** The following functions enable the appropriate channel of the currently enabled decoder */
-    void selectY0();
-    void selectY1();
-    void selectY2();
-    void selectY3();
-    void selectY4();
-    void selectY5();
-    void selectY6();
-    void selectY7();
-}
-
-#endif /* LINUX_GPIO_GPIOCALLBACKS_H_ */

bsp_q7s/main.cpp

@@ -12,8 +12,7 @@
  * @brief 	This is the main program for the target hardware.
  * @return
  */
-int main(void)
-{
+int main(void) {
   using namespace std;
 #if Q7S_SIMPLE_MODE == 0
   return obsw::obsw();

bsp_q7s/memory/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
     FileSystemHandler.cpp
     SdCardManager.cpp
     scratchApi.cpp

bsp_q7s/memory/FileSystemHandler.cpp

@@ -1,33 +1,31 @@
 #include "FileSystemHandler.h"
 
-#include "bsp_q7s/core/CoreController.h"
-
-#include "fsfw/tasks/TaskFactory.h"
-#include "fsfw/memory/GenericFileSystemMessage.h"
-#include "fsfw/ipc/QueueFactory.h"
-
 #include <cstring>
-#include <fstream>
 #include <filesystem>
+#include <fstream>
 
-FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler):
-        SystemObject(fileSystemHandler) {
-    mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE);
+#include "bsp_q7s/core/CoreController.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/memory/GenericFileSystemMessage.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler)
+    : SystemObject(fileSystemHandler) {
+  auto mqArgs = MqArgs(this->getObjectId());
+  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE,
+                                                    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
-FileSystemHandler::~FileSystemHandler() {
-    QueueFactory::instance()->deleteMessageQueue(mq);
-}
+FileSystemHandler::~FileSystemHandler() { QueueFactory::instance()->deleteMessageQueue(mq); }
 
 ReturnValue_t FileSystemHandler::performOperation(uint8_t unsignedChar) {
   while (true) {
     try {
       fileSystemHandlerLoop();
-        }
-        catch(std::bad_alloc& e) {
+    } catch (std::bad_alloc& e) {
       // Restart OBSW, hints at a memory leak
-            sif::error << "Allocation error in FileSystemHandler::performOperation"
-                    << e.what() << std::endl;
+      sif::error << "Allocation error in FileSystemHandler::performOperation" << e.what()
+                 << std::endl;
       // Set up an error file or a special flag in the scratch buffer for these cases
       triggerEvent(CoreController::ALLOC_FAILURE, 0, 0);
       CoreController::incrementAllocationFailureCount();
@@ -35,7 +33,6 @@ ReturnValue_t FileSystemHandler::performOperation(uint8_t unsignedChar) {
   }
 }
 
-
 void FileSystemHandler::fileSystemHandlerLoop() {
   CommandMessage filemsg;
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -48,10 +45,8 @@ void FileSystemHandler::fileSystemHandlerLoop() {
     result = mq->receiveMessage(&filemsg);
     if (result == MessageQueueIF::EMPTY) {
       break;
-        }
-        else if(result != HasReturnvaluesIF::RETURN_FAILED) {
-            sif::warning << "FileSystemHandler::performOperation: Message reception failed!"
-                    << std::endl;
+    } else if (result != HasReturnvaluesIF::RETURN_FAILED) {
+      sif::warning << "FileSystemHandler::performOperation: Message reception failed!" << std::endl;
       break;
     }
     Command_t command = filemsg.getCommand();
@@ -78,26 +73,23 @@ void FileSystemHandler::fileSystemCheckup() {
   sdcMan->getSdCardActiveStatus(statusPair);
   sd::SdCard preferredSdCard;
   sdcMan->getPreferredSdCard(preferredSdCard);
-    if((preferredSdCard == sd::SdCard::SLOT_0) and
-            (statusPair.first == sd::SdState::MOUNTED)) {
+  if ((preferredSdCard == sd::SdCard::SLOT_0) and (statusPair.first == sd::SdState::MOUNTED)) {
     currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-    }
-    else if((preferredSdCard == sd::SdCard::SLOT_1) and
+  } else if ((preferredSdCard == sd::SdCard::SLOT_1) and
              (statusPair.second == sd::SdState::MOUNTED)) {
     currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
-    }
-    else {
+  } else {
     std::string sdString;
     if (preferredSdCard == sd::SdCard::SLOT_0) {
       sdString = "0";
-        }
-        else {
+    } else {
       sdString = "1";
     }
     sif::warning << "FileSystemHandler::performOperation: "
-                "Inconsistent state detected" << std::endl;
-        sif::warning << "Preferred SD card is " << sdString <<
-                " but does not appear to be mounted. Attempting fix.." << std::endl;
+                    "Inconsistent state detected"
+                 << std::endl;
+    sif::warning << "Preferred SD card is " << sdString
+                 << " but does not appear to be mounted. Attempting fix.." << std::endl;
     // This function will appear to fix the inconsistent state
     ReturnValue_t result = sdcMan->sanitizeState(&statusPair, preferredSdCard);
     if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -108,15 +100,13 @@ void FileSystemHandler::fileSystemCheckup() {
   }
 }
 
-MessageQueueId_t FileSystemHandler::getCommandQueue() const {
-    return mq->getId();
-}
+MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); }
 
 ReturnValue_t FileSystemHandler::initialize() {
   coreCtrl = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
   if (coreCtrl == nullptr) {
-        sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle" <<
-                std::endl;
+    sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle"
+               << std::endl;
   }
   sdcMan = SdCardManager::instance();
   sd::SdCard preferredSdCard;
@@ -126,22 +116,20 @@ ReturnValue_t FileSystemHandler::initialize() {
   }
   if (preferredSdCard == sd::SdCard::SLOT_0) {
     currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-    }
-    else if(preferredSdCard == sd::SdCard::SLOT_1) {
+  } else if (preferredSdCard == sd::SdCard::SLOT_1) {
     currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t FileSystemHandler::appendToFile(const char* repositoryPath, const char* filename,
-        const uint8_t *data, size_t size, uint16_t packetNumber, void *args) {
-    // A double slash between repo and filename should not be an issue, so add it in any case
-    std::string fullPath = currentMountPrefix + std::string(repositoryPath) + "/" +
-            std::string(filename);
-    if(not std::filesystem::exists(fullPath)) {
+                                              const uint8_t* data, size_t size,
+                                              uint16_t packetNumber, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / filename;
+  if (not std::filesystem::exists(path)) {
     return FILE_DOES_NOT_EXIST;
   }
-    std::ofstream file(fullPath, std::ios_base::app|std::ios_base::out);
+  std::ofstream file(path, std::ios_base::app | std::ios_base::out);
   file.write(reinterpret_cast<const char*>(data), size);
   if (not file.good()) {
     return GENERIC_FILE_ERROR;
@@ -150,20 +138,13 @@ ReturnValue_t FileSystemHandler::appendToFile(const char *repositoryPath, const
 }
 
 ReturnValue_t FileSystemHandler::createFile(const char* repositoryPath, const char* filename,
-        const uint8_t *data, size_t size, void *args) {
-    std::string fullPath;
-    bool useMountPrefix = true;
-    parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-    if(useMountPrefix) {
-        fullPath += currentMountPrefix;
-    }
-
-    // A double slash between repo and filename should not be an issue, so add it in any case
-    fullPath += std::string(repositoryPath) + "/" + std::string(filename);
-    if(std::filesystem::exists(fullPath)) {
+                                            const uint8_t* data, size_t size,
+                                            FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / filename;
+  if (std::filesystem::exists(path)) {
     return FILE_ALREADY_EXISTS;
   }
-    std::ofstream file(fullPath);
+  std::ofstream file(path);
   file.write(reinterpret_cast<const char*>(data), size);
   if (not file.good()) {
     return GENERIC_FILE_ERROR;
@@ -172,20 +153,12 @@ ReturnValue_t FileSystemHandler::createFile(const char *repositoryPath, const ch
 }
 
 ReturnValue_t FileSystemHandler::removeFile(const char* repositoryPath, const char* filename,
-        void *args) {
-    std::string fullPath;
-    bool useMountPrefix = true;
-    parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-    if(useMountPrefix) {
-        fullPath += currentMountPrefix;
-    }
-
-    // A double slash between repo and filename should not be an issue, so add it in any case
-    fullPath += std::string(repositoryPath) + "/" + std::string(filename);
-    if(not std::filesystem::exists(fullPath)) {
+                                            FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / filename;
+  if (not std::filesystem::exists(path)) {
     return FILE_DOES_NOT_EXIST;
   }
-    int result = std::remove(fullPath.c_str());
+  int result = std::remove(path.c_str());
   if (result != 0) {
     sif::warning << "FileSystemHandler::deleteFile: Failed with code " << result << std::endl;
     return GENERIC_FILE_ERROR;
@@ -193,68 +166,51 @@ ReturnValue_t FileSystemHandler::removeFile(const char *repositoryPath, const ch
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t FileSystemHandler::createDirectory(const char *repositoryPath, void *args) {
-    std::string fullPath;
-    bool useMountPrefix = true;
-    parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-    if(useMountPrefix) {
-        fullPath += currentMountPrefix;
-    }
-
-    fullPath += std::string(repositoryPath);
-    if(std::filesystem::exists(fullPath)) {
+ReturnValue_t FileSystemHandler::createDirectory(const char* repositoryPath, const char* dirname,
+                                                 bool createParentDirs, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / dirname;
+  if (std::filesystem::exists(path)) {
     return DIRECTORY_ALREADY_EXISTS;
   }
-    if(std::filesystem::create_directory(fullPath)) {
+  if (std::filesystem::create_directory(path)) {
     return HasReturnvaluesIF::RETURN_OK;
   }
-    sif::warning << "Creating directory " << fullPath << " failed" << std::endl;
+  sif::warning << "Creating directory " << path << " failed" << std::endl;
   return GENERIC_FILE_ERROR;
 }
 
-ReturnValue_t FileSystemHandler::removeDirectory(const char *repositoryPath,
-        bool deleteRecurively, void *args) {
-    std::string fullPath;
-    bool useMountPrefix = true;
-    parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-    if(useMountPrefix) {
-        fullPath += currentMountPrefix;
-    }
-
-    fullPath += std::string(repositoryPath);
-    if(not std::filesystem::exists(fullPath)) {
+ReturnValue_t FileSystemHandler::removeDirectory(const char* repositoryPath, const char* dirname,
+                                                 bool deleteRecurively, FileSystemArgsIF* args) {
+  auto path = getInitPath(args) / repositoryPath / dirname;
+  if (not std::filesystem::exists(path)) {
     return DIRECTORY_DOES_NOT_EXIST;
   }
   std::error_code err;
   if (not deleteRecurively) {
-        if(std::filesystem::remove(fullPath, err)) {
+    if (std::filesystem::remove(path, err)) {
       return HasReturnvaluesIF::RETURN_OK;
-        }
-        else {
+    } else {
       // Check error code. Most probably denied permissions because folder is not empty
       sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                    "code " << err.value() << ": " << strerror(err.value()) << std::endl;
+                      "code "
+                   << err.value() << ": " << strerror(err.value()) << std::endl;
       if (err.value() == ENOTEMPTY) {
         return DIRECTORY_NOT_EMPTY;
-            }
-            else {
+      } else {
         return GENERIC_FILE_ERROR;
       }
-
     }
-    }
-    else {
-        if(std::filesystem::remove_all(fullPath, err)) {
+  } else {
+    if (std::filesystem::remove_all(path, err)) {
       return HasReturnvaluesIF::RETURN_OK;
-        }
-        else {
+    } else {
       sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                    "code " << err.value() << ": " << strerror(err.value()) << std::endl;
+                      "code "
+                   << err.value() << ": " << strerror(err.value()) << std::endl;
       // Check error code
       if (err.value() == ENOTEMPTY) {
         return DIRECTORY_NOT_EMPTY;
-            }
-            else {
+      } else {
         return GENERIC_FILE_ERROR;
       }
     }
@@ -263,8 +219,25 @@ ReturnValue_t FileSystemHandler::removeDirectory(const char *repositoryPath,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t FileSystemHandler::renameFile(const char* repositoryPath, const char* oldFilename,
+                                            const char* newFilename, FileSystemArgsIF* args) {
+  auto basepath = getInitPath(args) / repositoryPath;
+  std::filesystem::rename(basepath / oldFilename, basepath / newFilename);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 void FileSystemHandler::parseCfg(FsCommandCfg* cfg, bool& useMountPrefix) {
   if (cfg != nullptr) {
     useMountPrefix = cfg->useMountPrefix;
   }
 }
+
+std::filesystem::path FileSystemHandler::getInitPath(FileSystemArgsIF* args) {
+  bool useMountPrefix = true;
+  parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
+  std::string path;
+  if (useMountPrefix) {
+    path = currentMountPrefix;
+  }
+  return std::filesystem::path(path);
+}