Merge pull request 'Release v1.2.0' (#47) from develop into master

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

.dockerignore

@@ -0,0 +1,6 @@
+/build*
+generators
+misc
+tmtc
+doc
+

.gitignore

@@ -1,9 +1,19 @@
-_obj
-_bin
-_dep
+/build*
+
+Debug
+Debug*
+Release
+Release*
 
 .settings
 .metadata
 .project
 .cproject 
 __pycache__
+
+.idea
+
+!misc/eclipse/**/.cproject
+!misc/eclipse/**/.project
+
+generators/*.db

.gitmodules

@@ -1,12 +1,21 @@
 [submodule "etl"]
-	path = etl
+	path = thirdparty/etl
 	url = https://github.com/ETLCPP/etl.git
-[submodule "tmtc"]
-	path = tmtc
-	url = https://git.ksat-stuttgart.de/Robin.Mueller/tmtc.git
 [submodule "arduino"]
 	path = arduino
 	url = https://egit.irs.uni-stuttgart.de/eive/eive_arduino_interface.git
 [submodule "fsfw"]
 	path = fsfw
 	url = https://egit.irs.uni-stuttgart.de/eive/fsfw.git
+[submodule "tmtc"]
+	path = tmtc
+	url = https://egit.irs.uni-stuttgart.de/eive/eive_tmtc.git
+[submodule "thirdparty/lwgps"]
+	path = thirdparty/lwgps
+	url = https://github.com/rmspacefish/lwgps.git
+[submodule "fsfw_hal"]
+	path = fsfw_hal
+	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-hal.git
+[submodule "generators/fsfwgen"]
+	path = generators/fsfwgen
+	url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-generators.git

CMakeLists.txt

@@ -0,0 +1,250 @@
+################################################################################
+# CMake support for the EIVE OBSW
+# 
+# Developed in an effort to replace Make with a modern build system.
+# 
+# Author: R. Mueller
+################################################################################
+
+################################################################################
+# Pre-Project preparation
+################################################################################
+cmake_minimum_required(VERSION 3.13)
+
+# set(CMAKE_VERBOSE TRUE)
+
+set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+option(ADD_ETL_LIB "Add ETL library" ON)
+if(NOT OS_FSFW)
+	set(OS_FSFW host CACHE STRING "OS for the FSFW.")
+endif()
+
+if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
+    option(LINUX_CROSS_COMPILE ON)
+endif()
+
+# Perform steps like loading toolchain files where applicable.
+include(${CMAKE_SCRIPT_PATH}/PreProjectConfig.cmake)
+pre_project_config()
+
+# Project Name
+project(eive_obsw ASM C CXX)
+
+################################################################################
+# Pre-Sources preparation
+################################################################################
+
+# Specify the C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Set names and variables
+set(TARGET_NAME ${CMAKE_PROJECT_NAME}) 
+set(LIB_FSFW_NAME fsfw)
+set(LIB_ETL_NAME etl)
+set(LIB_CSP_NAME libcsp)
+set(LIB_FSFW_HAL_NAME fsfw_hal)
+set(LIB_LWGPS_NAME lwgps)
+set(THIRD_PARTY_FOLDER thirdparty)
+
+# Set path names
+set(FSFW_PATH fsfw)
+set(MISSION_PATH mission)
+set(TEST_PATH test/testtasks)
+set(LINUX_PATH linux)
+set(COMMON_PATH common)
+set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
+
+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(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
+set(ADD_LINUX_FILES False)
+
+# Analyse different OS and architecture/target options, determine BSP_PATH,
+# display information about compiler etc.
+include (${CMAKE_SCRIPT_PATH}/HardwareOsPreConfig.cmake)
+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"
+    )
+        set(FSFW_CONFIG_PATH "linux/fsfwconfig")
+        set(ADD_LINUX_FILES TRUE)
+        set(ADD_CSP_LIB TRUE)
+        set(FSFW_HAL_ADD_LINUX ON)
+    endif()
+   
+    if(${TGT_BSP} MATCHES "arm/raspberrypi") 
+        add_definitions(-DRASPBERRY_PI)
+        set(FSFW_HAL_ADD_RASPBERRY_PI ON)
+    endif()
+    
+    if(${TGT_BSP} MATCHES "arm/beagleboneblack") 
+        add_definitions(-DBEAGLEBONEBLACK)
+    endif()
+    
+    if(${TGT_BSP} MATCHES "arm/q7s")
+        add_definitions(-DXIPHOS_Q7S)
+    endif()
+else()
+    # Required by FSFW library
+    set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
+endif()
+
+# Configuration files
+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")
+    configure_file(${BSP_PATH}/boardconfig/rpiConfig.h.in rpiConfig.h)
+endif()
+
+# Set common config path for FSFW
+set(FSFW_ADDITIONAL_INC_PATHS 
+    "${COMMON_PATH}/config"
+    ${CMAKE_CURRENT_BINARY_DIR}
+)
+# Set for lwgps library
+set(LWGPS_CONFIG_PATH "${COMMON_PATH}/config")
+
+################################################################################
+# Executable and Sources
+################################################################################
+
+# Add executable
+add_executable(${TARGET_NAME})
+
+if(ADD_CSP_LIB)
+    add_subdirectory(${CSP_LIB_PATH})
+endif()
+
+if(ADD_ETL_LIB)
+    add_subdirectory(${ETL_LIB_PATH})
+endif()
+
+if(ADD_LINUX_FILES)
+    add_subdirectory(${LINUX_PATH})
+endif()
+
+add_subdirectory(${LWGPS_LIB_PATH})
+add_subdirectory(${BSP_PATH})
+add_subdirectory(${FSFW_PATH})
+add_subdirectory(${MISSION_PATH})
+add_subdirectory(${TEST_PATH})
+add_subdirectory(${FSFW_HAL_LIB_PATH})
+add_subdirectory(${COMMON_PATH})
+
+################################################################################
+# Post-Sources preparation
+################################################################################
+
+set_property(CACHE OS_FSFW PROPERTY STRINGS host linux)
+
+# Add libraries for all sources.
+target_link_libraries(${TARGET_NAME} PRIVATE
+	${LIB_FSFW_NAME} 
+	${LIB_OS_NAME} 
+	${LIB_LWGPS_NAME}
+	${LIB_FSFW_HAL_NAME}
+)
+
+if(ADD_ETL_LIB)
+    target_link_libraries(${TARGET_NAME} PRIVATE
+        ${LIB_ETL_NAME}
+    )
+endif()
+
+if(ADD_CSP_LIB)
+	target_link_libraries(${TARGET_NAME} PRIVATE
+		${LIB_CSP_NAME}
+	)
+endif()
+
+# Add include paths for all sources.
+target_include_directories(${TARGET_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${FSFW_CONFIG_PATH}
+	${CMAKE_CURRENT_BINARY_DIR}
+)	
+
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	set(WARNING_FLAGS
+		-Wall
+		-Wextra
+		-Wimplicit-fallthrough=1
+		-Wno-unused-parameter
+		-Wno-psabi
+	)
+	
+	# Remove unused sections.
+	target_compile_options(${TARGET_NAME} PRIVATE
+		"-ffunction-sections"
+		"-fdata-sections"
+	)
+
+	# Removed unused sections.
+	target_link_options(${TARGET_NAME} PRIVATE
+		"-Wl,--gc-sections"
+	)
+	
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+	set(COMPILER_FLAGS "/permissive-")
+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)
+	post_source_hw_os_config()
+endif()
+
+if(NOT CMAKE_SIZE)
+	set(CMAKE_SIZE size)
+	if(WIN32)
+		set(FILE_SUFFIX ".exe")
+	endif()
+endif()
+
+if(TGT_BSP)
+	set(TARGET_STRING "Target BSP: ${TGT_BSP}")
+else()
+	set(TARGET_STRING "Target BSP: Hosted")
+endif()
+
+string(CONCAT POST_BUILD_COMMENT
+    "Build directory: ${CMAKE_BINARY_DIR}\n"
+    "Target OSAL: ${OS_FSFW}\n"
+    "Target Build Type: ${CMAKE_BUILD_TYPE}\n"
+    "${TARGET_STRING}"
+)
+
+add_custom_command(
+   TARGET ${TARGET_NAME}
+   POST_BUILD
+   COMMAND ${CMAKE_SIZE} ${TARGET_NAME}${FILE_SUFFIX}
+   COMMENT ${POST_BUILD_COMMENT}
+)
+
+include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
+set_build_type()
+
+
+
+
+

README.md

@@ -4,7 +4,7 @@
 
 Target systems:
 
-* OBC
+* OBC with Linux OS
 	* Xiphos Q7S
 	* Based on Zynq-7020 SoC (xc7z020clg484-2)
 		* Dual-core ARM Cortex-A9 
@@ -12,56 +12,193 @@ Target systems:
 		* Artix-7 FPGA (85K pogrammable logic cells)
 	* Datasheet at https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Arbeitsdaten/08_Used%20Components/Q7S&fileid=340648
 	* Also a lot of informatin about the Q7S can be found on the xiphos trac platform: https://trac.xiphos.com/trac/eive-q7/wiki/Q7RevB
-* Linux OS
-	* Built with Yocto 2.5
+	* Linux OS built with Yocto 2.5
 	* Linux Kernel https://github.com/XiphosSystemsCorp/linux-xlnx.git
 * Host System
 	* Generic software components which are not dependant on hardware can also
-	  be run. All host code is contained in the hosted folder
+	be run on a host system. All host code is contained in the `bsp_hosted` folder
 	* Tested for Linux (Ubuntu 20.04) and Windows 10
+* Raspberry Pi
+    * EIVE OBC can be built for Raspberry Pi as well (either directly on Raspberry Pi or by installing a cross compiler)
 	
+The steps in the primary README are related to the main OBC target Q7S.
+The CMake build system can be used to generate build systems as well (see helper scripts in `cmake/scripts`:
+
+- Linux (Raspberry Pi): See special section below.
+- Linux Host:  Uses the `bsp_hosted` BSP folder and the CMake Unix Makefiles generator.
+- Windows Host: Uses the `bsp_hosted` BSP folder, the CMake MinGW Makefiles generator and MSYS2.
 
 ## Setting up development environment
+
+### Installing Vivado the the Xilinx development tools
+
+It's also possible to perform debugging with a normal Eclipse installation by installing 
+the TCF plugin and downloading the cross-compiler as specified in the section below.
+
 * Install Vivado 2018.2 and Xilinx SDK from https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/vivado-design-tools/archive.html.
-  Install the Vivado Design Suite - HLx Editions - 2018.2  Full Product Installation instead of the updates. It is recommended to use the installer
+  Install the Vivado Design Suite - HLx Editions - 2018.2  Full Product Installation instead of the updates. It is recommended to use the installer.
+  
 * Install settings. In the Devices selection, it is sufficient to pick SoC &rarr; Zynq-7000: <br>
-  <img src="./doc/img/xilinx-install.PNG" width="50%"> <br>
+
+<img src="./doc/img/vivado-edition.png" width="50%"> <br>
+
+<img src="./doc/img/vivado-hl-design.png" width="50%"> <br>
+
+<img src="./doc/img/xilinx-install.PNG" width="50%"> <br>
+
 * For supported OS refer to https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_2/ug973-vivado-release-notes-install-license.pdf
-* Add path of linux cross-compiler to environment variables SDK\2018.2\gnu\aarch32\nt\gcc-arm-linux-gnueabi\bin
-* Install make (only on windows, SDK on Linux can use the make installed with the SDK)
+* Add path of linux cross-compiler to permanent environment variables (`.profile` file in Linux): 
+  `<XilinxInstallation>\SDK\2018.2\gnu\aarch32\nt\gcc-arm-linux-gnueabi\bin` 
+  or set up path each time before debugging.
 
-### Installing make on Windows
-1. Install NodeJS LTS
-2. Install xpm
-	
-```sh
-npm install --global xpm
-```
+### Installing toolchain without Vivado
 
-3. Install Windows build tools (after installation also linux commands like mkdir can be used from windows) 
+You can download the toolchains for Windows and Linux
+[from the EIVE cloud](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files?dir=/EIVE_IRS/Software/tools&fileid=831898).
+
+If `wget` is available (e.g. MinGW64), you can use the following command to download the
+toolchain for Windows
 
 ```sh
-xpm install --global @xpack-dev-tools/windows-build-tools@latest
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/rfoaistRd67yBbH/download/gcc-arm-linux-gnueabi-win.zip
 ```
 
-## Building the software
+or the following command for Linux (could be useful for CI/CD)
+
+```sh
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/2Fp2ag6NGnbtAsK/download/gcc-arm-linux-gnueabi.tar.gz
+```
+
+### Installing CMake and MSYS2 on Windows
+
+1. Install [MSYS2](https://www.msys2.org/) and [CMake](https://cmake.org/download/) first.
+
+2. Open the MinGW64 console. It is recommended to set up aliases in `.bashrc` to navigate to the 
+   software repository quickly
+  
+3. Run the following commands in MinGW64
+
+   ```sh
+   pacman -Syuuu
+   ```
+   
+   It is recommended to install the full base development toolchain
+   
+   ```sh
+   pacman -S base-devel
+   ```
+   
+   It is also possible to only install required packages
+   
+   ```sh
+   pacman -S mingw-w64-x86_64-cmake mingw-w64-x86_64-make mingw-w64-x86_64-gcc mingw-w64-x86_64-gdb python3
+   ```
+   
+### Installing CMake on Linux
+
+1. Run the following command
+
+   ```sh
+   sudo apt-get install cmake
+   ```` 
+   
+## Getting the Q7S system root
+
+It is necessary to copy the Q7S system root to your local development machine for libraries
+like `libgpio`. You can find the system root for the Q7S, the Raspberry Pi and the
+Beagle Bone Black for download here
+[here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/rootfs&fileid=831849). 
+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
+```
+
+Then, create a new environmental variables `Q7S_SYSROOT` and set it to the local system root path.
+
+## Building the software with CMake
+
+When using Windows, run theses steps in MSYS2.
 
 1. Clone the repository with
-```sh
-git clone https://egit.irs.uni-stuttgart.de/eive/eive_obsw.git
-```
+
+   ```sh
+   git clone https://egit.irs.uni-stuttgart.de/eive/eive_obsw.git
+   ```
 
 2. Update all the submodules
-```sh
-git submodule init
-git submodule sync
-git submodule update
-```
 
-3. Open Xilinx SDK 2018.2
-4. Import project
+   ```sh
+   git submodule init
+   git submodule sync
+   git submodule update
+   ```
+
+3. Ensure that the cross-compiler is working with `arm-linux-gnueabihf-gcc --version`.
+   It is recommended to run the shell script `win_path_helper_xilinx_tools.sh` in `cmake/scripts/Q7S`
+   or to set up the [PATH and the CROSS_COMPILE variable permanently](https://unix.stackexchange.com/questions/26047/how-to-correctly-add-a-path-to-path)
+   in the `.profile` file.
+
+4. Run the CMake configuration to create the build system in a `build-Debug-Q7S` folder.
+   Add `-G "MinGW Makefiles` in MinGW64 on Windows.
+
+   ```sh
+   mkdir build-Debug-Q7S && cd build-Debug-Q7S
+   cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug -DOS_FSFW=linux ..
+   cmake --build . -j
+   ```
+
+   You can also use provided shell scripts to perform these commands
+
+   ```sh
+   cd cmake/scripts/Q7S
+   ./create_cmake_debug.sh
+   cd ../../..
+   ```
+
+   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
+   or the Beagle Bone Black: `arm/raspberrypi` and `arm/beagleboneblack`.
+   
+5. Build the software with
+   ```sh
+   cd Debug
+   cmake --build . -j
+   ```
+   
+## Setting up default Eclipse for Q7S projects - TCF agent
+
+The [TCF agent](https://wiki.eclipse.org/TCF) can be used to perform remote debugging on the Q7S.
+
+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.
+
+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. Please note that you have to connect to `localhost` and port `1534` with port forwaring set up.
+   
+3. A launch configuration was provided, but it might be necessary to adapt it for your own needs. Alternatively:
+
+ - Create a new **TCF Remote Application** by pressing the cogs button at the top or going to Run &rarr; Debug Configurations &rarr; Remote Application and creating a new one there. 
+
+ - Set up the correct image in the main tab (it might be necessary to send the image to the Q7S manually once) and file transfer properties
+
+ - It is also recommended to link the correct Eclipse project. 
+
+After that, comfortable remote debugging should be possible with the Debug button.
+
+A build configuration and a shell helper script has been provided to set up the path variables and 
+build the Q7S binary on Windows, but a launch configuration needs to be newly created because the 
+IP address and path settings differ from machine to machine.
+
+## Building in Xilinx SDK 2018.2
+
+1. Open Xilinx SDK 2018.2
+2. Import project
 	* File &rarr; Import &rarr; C/C++ &rarr; Existing Code as Makefile Project
-5. Set build command. Replace \<target\> with either debug or release.
+3. Set build command. Replace \<target\> with either debug or release.
 	* When on Linux right click project &rarr; Properties &rarr; C/C++ Build &rarr; Set build command to `make <target>  -j`
 		* -j causes the compiler to use all available cores
 		* The target is used to either compile the debug or the optimized release build.
@@ -70,153 +207,189 @@ git submodule update
 		* Target name: all
 		* Uncheck "Same as the target name"
 		* Uncheck "Use builder settings"
-		* As build command type: `make -j <target> WINDOWS=1`
-6. Run build command by double clicking the created target or by right clicking
+		* As build command type: `cmake --build .`
+		* In the Behaviour tab, you can enable build acceleration
+4. Run build command by double clicking the created target or by right clicking
    the project folder and selecting Build Project.
 
-## Debugging the software (when workstation is directly conncected to Q7S)
-1. Assign static IP address to Q7S
-	* Open serial console of Q7S (Accessible via the micro-USB of the PIM, see also Q7S user maunal chapter 10.3)
-	* Baudrate 115200
-	* Login to Q7S:
-		* user: root
-		* pw: root
-	* Set IP address and netmask with
-	
-    ```sh
+## TCF-Agent 
+
+1. On reboot, some steps have to be taken on the Q7S. Set static IP address and netmask
+
+	```sh
     ifconfig eth0 192.168.133.10
     ifconfig eth0 netmask 255.255.255.0
     ``` 
 	
-2. Connect Q7S to workstation via ethernet
-3. Make sure the netmask of the ehternet interface of the workstation matches the netmask of the Q7S
-	* When IP address is set to 192.168.133.10 and the netmask is 255.255.255.0, an example IP address for the workstation
-	  is 192.168.133.2
-4. Run tcf-agent on Q7S
-	* Tcf-agent is not yet integrated in the rootfs of the Q7S. Therefore build tcf-agent manually
-	
-    ```sh
-    git clone git://git.eclipse.org/gitroot/tcf/org.eclipse.tcf.agent.git
-    cd org.eclipse.tcf.agent/agent
-    make CC=arm-linux-gnueabihf-gcc LD=arm-linux-gnueabihf-ld MACHINE=arm NO_SSL=1 NO_UUID=1
-    ```
+2. `tcfagent` application should run automatically but this can be checked with
+    ```sh 
+	systemctl status tcfagent
+	```
 
-	* Transfer executable agent from org.eclipse.tcf.agent/agent/obj/GNU/Linux/arm/Debug to /tmp of Q7S
-	
-    ```sh
-    cd obj/GNU/Linux/arm/Debug
-    scp agent root@192.168.133.10:/tmp
-    ```
-
-	* On Q7S 
-    ```sh
-    cd /tmp
-    chmod +x agent
-    ```
-
-	* Run agent
-    ```sh
-    ./agent
-    ```
-
-5. In Xilinx SDK 2018.2 right click on project &rarr; Debug As &rarr; Debug Configurations
-6. Right click Xilinx C/C++ applicaton (System Debugger) &rarr; New &rarr; 
-7. Set Debug Type to Linux Application Debug and Connectin to Linux Agent
-8. Click New
-9. Give connection a name
-10. Set Host to static IP address of Q7S. e.g. 192.168.133.10
-11. Test connection (This ensures the TCF Agent is running on the Q7S)
-12. Select Application tab
-	* Project Name: eive_obsw
-	* Local File Path: Path to eiveobsw-linux.elf (in _bin\linux\devel)
-	* Remote File Path: /tmp/eive_obsw.elf
+3. If the agent is not running, check whether `agent` is located inside `usr/bin`.
+   You can run it manually there. To perform auto-start on boot, have a look at the start-up 
+   application section.
 
 ## Debugging the software via Flatsat PC
+
 Open SSH connection to flatsat PC:
-````
+
+```sh
+ssh eive@flatsat.eive.absatvirt.lw
+```
+
+or
+
+```sh
 ssh eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5
-````
-To access the console of the Q7S run the following:
+```
+
+or 
+
+```sh
+ssh eive@192.168.199.227
+```
+
+If the static IP address of the Q7S has already been set,
+you can access it with ssh
+
+```sh
+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
+
 ```sh
 picocom -b 115200 /dev/ttyUSB0
 ```
+
+If the serial port is blocked for some reason, you can kill 
+the process using it with `q7s_kill`.
+
+You can use `AltGr` + `X` to exit the picocom session.
+
 To debug an application, first make sure a static IP address is assigned to the Q7S. Run ifconfig on the Q7S serial console.
-````
+
+```sh
 ifconfig
-````
+```
+
 Set IP address and netmask with
-````
+
+```sh
 ifconfig eth0 192.168.133.10
 ifconfig eth0 netmask 255.255.255.0
-````
-To launch application from Xilinx SDK setup port fowarding on the localhost.
-````
-ssh -L 1534:192.168.133.10:1534 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5
-````
+```
+
+To launch application from Xilinx SDK setup port fowarding on the development machine
+(not on the flatsat!)
+
+```sh
+ssh -L 1534:192.168.133.10:1534 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5 -t bash
+```
+
 This forwards any requests to localhost:1534 to the port 1534 of the Q7S with the IP address 192.168.133.10.
+This needs to be done every time, so it is recommended to create an alias to do this quickly.
 
-Note: When now setting up a debug session in the Xilinx SDK, the host must be set to localhost instead of the IP address
-      of the Q7S.
+Note: When now setting up a debug session in the Xilinx SDK, the host must be set to localhost instead of the IP address of the Q7S.
 
+## Transfering files via SCP
+
+To transfer files from the local machine to the Q7S, use port forwarding
+
+```sh
+ssh -L 1535:192.168.133.10:22 eive@2001:7c0:2018:1099:babe:0:e1fe:f1a5
+```
+
+An `example` file can be copied like this
+
+```sh
+scp -P 1535 example root@localhost:/tmp
+```
+
+Copying a file from Q7S to flatsat PC 
+````
+scp -P 22 root@192.168.133.10:/tmp/kernel-config /tmp
+````
+
+From a windows machine files can be copied with putty tools (note: use IPv4 address)
+````
+pscp -scp -P 22 eive@192.168.199.227:</directory-to-example-file/>/example-file </windows-machine-path/>
+````
+
+## Launching an application at start-up
 
-## Launching an application after boot
 Load the root partiton from the flash memory (there are to nor-flash memories and each flash holds two xdi images).
-Note: It is not possible to modify the current loaded root partition.
+Note: It is not possible to modify the currently loaded root partition, e.g. creating directories. To do this, 
+the parition needs to be mounted.
+
 1. Disable write protection of the desired root partition
-````
-writeprotect 0 0 0 # unlocks nominal image on nor-flash 0
-````
+
+   ```sh
+   writeprotect 0 0 0 # unlocks nominal image on nor-flash 0  
+   ```
+
 2. Mount the root partition
-````
-xsc_mount_copy 0 0 # Mounts the nominal image from nor-flash 0
-````
-3. Copy the executable to /bin/usr
+
+   ```sh
+   xsc_mount_copy 0 0 # Mounts the nominal image from nor-flash 0
+   ```
+   The mounted partition will be located inside the `/tmp` folder
+   
+3. Copy the executable to `/usr/bin`
+
 4. Make sure the permissions to execute the application are set
-````
-chmod +x application
-````
+   ```sh
+   chmod +x application
+   ```
+   
 5. Create systemd service in /lib/systemd/system. The following shows an example service.
-````
-cat > example.service
-[Unit]
-Description=Example Service
-StartLimitIntervalSec=0
+   ```sh
+   cat > example.service
+   [Unit]
+   Description=Example Service
+   StartLimitIntervalSec=0
 
-[Service]
-Type=simple
-Restart=always
-RestartSec=1
-User=root
-ExecStart=/usr/bin/application
+   [Service] 
+   Type=simple
+   Restart=always
+   RestartSec=1
+   User=root
+   ExecStart=/usr/bin/application
 
-[Install]
-WantedBy=multi-user.target
-````
+   [Install]
+   WantedBy=multi-user.target
+   ```
 6. Enable the service. This is normally done with systemctl enable. However, this is not possible when the service is
    created for a mounted root partition. Therefore create a symlink as follows.
-````
-ln -s '/tmp/the-mounted-xdi-image/lib/systemd/system/example.service' '/tmp/the-mounted-xdi-image/etc/systemd/system/multi-user.target.wants/example.service'
-````
+   ```sh
+   ln -s '/tmp/the-mounted-xdi-image/lib/systemd/system/example.service' '/tmp/the-mounted-xdi-image/etc/systemd/system/multi-user.target.wants/example.service'
+   ```
+   
 7. The modified root partition is written back when the partion is locked again. 
-````
-writeprotect 0 0 1 
-````
+   ```sh
+   writeprotect 0 0 1 
+   ```
 8. Now verify the application start by booting from the modified image
-````
-xsc_boot_copy 0 0
-````
+   ```sh
+   xsc_boot_copy 0 0
+   ````
+   
 9. After booting verify if the service is running 
-````
-systemctl status example
-````
+   ```sh
+   systemctl status example
+   ```
 More detailed information about the used q7s commands can be found in the Q7S user manual.
 
 ### Bringing up CAN
-````
-ip link set can0 down
-ip link set can0 type can loopback off
-ip link set can0 up type can bitrate 1000000
-````
+
+   ```sh
+   ip link set can0 down
+   ip link set can0 type can loopback off
+   ip link set can0 up type can bitrate 1000000
+   ```
+   
 Following command sends 8 bytes to device with id 99 (for petalinux)
 ````
 cansend can0 -i99 99 88 77 11 33 11 22 99
@@ -293,17 +466,6 @@ a permanent solution). If running the script before executing the binary does
 not help or an warning is issue that the soft real time value is invalid, 
 the hard real-time limit of the system might not be high enough (see step 1).
 
-## Building and running the software on a host system
-
-The host build can be built with following command
-
-```sh
-make -f Makefile-Hosted all -j
-```
-
-If compiling on Windows, it is recommended to supply `WINDOWS=1` .
-A release build can be built by using the `mission` target.
-
 ## Flight Software Framework (FSFW)
 
 An EIVE fork of the FSFW is submodules into this repository.
@@ -323,3 +485,185 @@ git merge upstream/master
 
 Alternatively, changes from other upstreams (forks) and branches can be merged like that in
 the same way.
+
+## PCDU
+
+Connect to serial console of P60 Dock
+````
+picocom -b 500000 /dev/ttyUSBx
+````
+General information
+````
+cmp ident
+````
+List parameter table:
+x values: 1,2 or 4
+````
+param list x
+````
+Table 4 lists HK parameters
+Changing parameters
+First switch to table where parameter shall be changed (here table id is 1)
+````
+p60-dock # param mem 1
+p60-dock # param set out_en[0] 1
+p60-dock # param get out_en[0]
+GET out_en[0] = 1
+````
+
+## Debugging the software (when workstation is directly conncected to Q7S)
+
+1. Assign static IP address to Q7S
+	* Open serial console of Q7S (Accessible via the micro-USB of the PIM, see also Q7S user maunal chapter 10.3)
+	* Baudrate 115200
+	* Login to Q7S:
+		* user: root
+		* pw: root
+	
+2. Connect Q7S to workstation via ethernet
+3. Make sure the netmask of the ehternet interface of the workstation matches the netmask of the Q7S
+	* When IP address is set to 192.168.133.10 and the netmask is 255.255.255.0, an example IP address for the workstation
+	  is 192.168.133.2
+	  
+4. Run tcf-agent on Q7S
+
+	* Tcf-agent is not yet integrated in the rootfs of the Q7S. Therefore build tcf-agent manually
+	
+    ```sh
+    git clone git://git.eclipse.org/gitroot/tcf/org.eclipse.tcf.agent.git
+    cd org.eclipse.tcf.agent/agent
+    make CC=arm-linux-gnueabihf-gcc LD=arm-linux-gnueabihf-ld MACHINE=arm NO_SSL=1 NO_UUID=1
+    ```
+
+	* Transfer executable agent from org.eclipse.tcf.agent/agent/obj/GNU/Linux/arm/Debug to /tmp of Q7S
+	
+    ```sh
+    cd obj/GNU/Linux/arm/Debug
+    scp agent root@192.168.133.10:/tmp
+    ```
+
+	* On Q7S 
+    ```sh
+    cd /tmp
+    chmod +x agent
+    ```
+
+	* Run agent
+    ```sh
+    ./agent
+    ```
+
+5. In Xilinx SDK 2018.2 right click on project &rarr; Debug As &rarr; Debug Configurations
+6. Right click Xilinx C/C++ applicaton (System Debugger) &rarr; New &rarr; 
+7. Set Debug Type to Linux Application Debug and Connectin to Linux Agent
+8. Click New
+9. Give connection a name
+10. Set Host to static IP address of Q7S. e.g. 192.168.133.10
+11. Test connection (This ensures the TCF Agent is running on the Q7S)
+12. Select Application tab
+	* Project Name: eive_obsw
+	* Local File Path: Path to eiveobsw-linux.elf (in _bin\linux\devel)
+	* Remote File Path: /tmp/eive_obsw.elf
+
+## Running cppcheck on the Software
+
+Static code analysis can be useful to find bugs.
+`cppcheck` can be used for this purpose. On Windows you can use MinGW64 to do this.
+
+```sh
+pacman -S mingw-w64-x86_64-cppcheck
+```
+
+On Ubuntu, install with
+
+```sh
+sudo apt-get install cppcheck
+```
+
+You can use the Eclipse integration or you can perform the scanning manually from the command line.
+CMake will be used for this.
+
+Run the CMake build generation commands specified above but supply
+`-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` to the build generation. Invoking the build command will
+generate a `compile_commands.json` file which can be used by cppcheck.
+
+```sh
+cppcheck --project=compile_commands.json --xml 2> report.xml
+```
+
+Finally, you can convert the generated `.xml` file to HTML with the following command
+
+```sh
+cppcheck-htmlreport --file=report.xml --report-dir=cppcheck --source-dir=..
+```
+
+## Libgpiod
+
+Detect all gpio device files:
+````
+gpiodetect
+````
+Get info about a specific gpio group:
+````
+gpioinfo <name of gpio group>
+````
+The following sets the gpio 18 from gpio group gpiochip7 to high level.
+````
+gpioset gpiochip7 18=1
+````
+Setting the gpio to low.
+````
+gpioset gpiochip7 18=0
+````
+Show options for setting gpios.
+````
+gpioset -h
+```` 
+To get the state of a gpio:
+````
+gpioget <gpiogroup> <offset>
+````
+Example to get state:
+gpioget gpiochip7 14
+
+## Running the EIVE OBSW on a Raspberry Pi
+
+Special section for running the EIVE OBSW on the Raspberry Pi.
+The Raspberry Pi build uses the `bsp_rpi` BSP folder, and a very similar cross-compiler.
+
+For running the software on a Raspberry Pi, it is recommended to follow the steps specified in 
+[the fsfw example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example/src/branch/mueller/master/doc/README-rpi.md#top) 
+and using the TCF agent to have a similar set-up process also required for the Q7S.
+You should run the following command first on your Raspberry Pi
+
+```sh
+sudo apt-get install gpiod libgpiod-dev
+```
+
+to install the required GPIO libraries before cloning the system root folder.
+
+## Special notes on Eclipse
+
+When using Eclipse, there are two special build variables in the project properties
+&rarr; C/C++ Build &rarr; Build Variables called `Q7S_SYSROOT` or `RPI_SYSROOT`. You can set 
+the sysroot path in those variables to get any additional includes like `gpiod.h` in the 
+Eclipse indexer.
+
+## Xilinx UARTLIE
+Get info about ttyUL* devices
+````
+cat /proc/tty/driver
+````
+
+## I2C
+Getting information about I2C device
+````
+ls /sys/class/i2c-dev/i2c-0/device/device/driver
+````
+This shows the memory mapping of /dev/i2c-0
+
+## Useful Q7S Linux Commands
+Rebooting currently running image:
+````
+xsc_boot_copy -r
+````

bsp_hosted/CMakeLists.txt

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

bsp_hosted/Dockerfile

@@ -0,0 +1,21 @@
+FROM ubuntu:latest
+# FROM alpine:latest
+
+ENV TZ=Europe/Berlin
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && apt-get install -y cmake g++
+# RUN apk add cmake make g++
+
+WORKDIR /usr/src/app
+COPY . .
+
+RUN set -ex; \
+    rm -rf build-hosted; \
+    mkdir build-hosted; \
+    cd build-hosted; \
+    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux ..;
+
+ENTRYPOINT ["cmake", "--build", "build-hosted"]
+CMD ["-j"]
+# CMD ["bash"]

bsp_hosted/InitMission.cpp

@@ -0,0 +1,159 @@
+#include "InitMission.h"
+#include "ObjectFactory.h"
+
+#include <OBSWConfig.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>
+
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+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);
+    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();
+    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);
+    ReturnValue_t 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;
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
+            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+    result = udpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    }
+    PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
+            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+    result = udpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "Add component UDP Polling failed" << std::endl;
+    }
+
+    /* PUS Services */
+    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;
+    }
+
+    PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
+            "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+    result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+    if(result != HasReturnvaluesIF::RETURN_OK){
+        initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    PeriodicTaskIF* testTask = factory->createPeriodicTask(
+            "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+#if OBSW_ADD_TEST_CODE == 1
+    result = testTask->addComponent(objects::TEST_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+    }
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+    sif::info << "Starting tasks.." << std::endl;
+    tmTcDistributor->startTask();
+    udpBridgeTask->startTask();
+    udpPollingTask->startTask();
+
+    pusVerification->startTask();
+    pusEvents->startTask();
+    pusHighPrio->startTask();
+    pusMedPrio->startTask();
+    pusLowPrio->startTask();
+
+#if OBSW_ADD_TEST_CODE == 1
+    testTask->startTask();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+    sif::info << "Tasks started.." << std::endl;
+}

bsp_hosted/InitMission.h

@@ -1,7 +1,7 @@
 #ifndef BSP_LINUX_INITMISSION_H_
 #define BSP_LINUX_INITMISSION_H_
 
-namespace InitMission {
+namespace initmission {
 void initMission();
 void initTasks();
 };

bsp_hosted/ObjectFactory.cpp

@@ -1,20 +1,27 @@
 #include "ObjectFactory.h"
 
-#include <objects/systemObjectList.h>
 #include <OBSWConfig.h>
+#include <objects/systemObjectList.h>
 #include <tmtc/apid.h>
 #include <tmtc/pusIds.h>
 
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
-#include <fsfw/osal/linux/TmTcUnixUdpBridge.h>
-#include <fsfw/tmtcpacket/pus/TmPacketStored.h>
-#include <fsfw/osal/linux/TcUnixUdpPollingTask.h>
 
 #include <mission/core/GenericFactory.h>
 #include <mission/utility/TmFunnel.h>
 
-void Factory::setStaticFrameworkObjectIds() {
+#include <fsfw/osal/common/UdpTcPollingTask.h>
+#include <fsfw/osal/common/UdpTmTcBridge.h>
+
+#include <fsfw/tmtcpacket/pus/tm.h>
+
+
+#if OBSW_ADD_TEST_CODE == 1
+#include <test/testtasks/TestTask.h>
+#endif
+
+void Factory::setStaticFrameworkObjectIds(){
 	PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
 	PusServiceBase::packetDestination = objects::TM_FUNNEL;
 
@@ -26,17 +33,14 @@ void Factory::setStaticFrameworkObjectIds() {
 	TmFunnel::storageDestination = objects::NO_OBJECT;
 
 	VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-	TmPacketStored::timeStamperId = objects::TIME_STAMPER;
+	TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }
 
-
-
-void ObjectFactory::produce(){
+void ObjectFactory::produce(void* args){
 	Factory::setStaticFrameworkObjectIds();
 	ObjectFactory::produceGenericObjects();
 
-	new TmTcUnixUdpBridge(objects::UDP_BRIDGE,
-			objects::CCSDS_PACKET_DISTRIBUTOR,
-			objects::TM_STORE, objects::TC_STORE);
-	new TcUnixUdpPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+
 }

bsp_hosted/ObjectFactory.h

@@ -1,17 +1,10 @@
-/*
- * ObjectFactory.h
- *
- *  Created on: Sep 22, 2020
- *      Author: steffen
- */
-
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_
 
 
 namespace ObjectFactory {
 	void setStatics();
-	void produce();
+	void produce(void* args);
 };
 
 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_hosted/boardconfig/CMakeLists.txt

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

bsp_hosted/boardconfig/print.c

@@ -1,4 +1,5 @@
 #include "print.h"
+
 #include <stdio.h>
 
 void printChar(const char* character, bool errStream) {

bsp_hosted/boardconfig/print.h

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

bsp_hosted/bsp_hosted.mk

@@ -7,4 +7,5 @@ CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c)
 CXXSRC += $(wildcard $(CURRENTPATH)/comIF/*.cpp)
 CSRC += $(wildcard $(CURRENTPATH)/comIF/*.c)
 
-INCLUDES += $(CURRENTPATH)/boardconfig
+INCLUDES += $(CURRENTPATH)/boardconfig
+INCLUDES += $(CURRENTPATH)/fsfwconfig

bsp_hosted/comIF/ArduinoComIF.cpp

@@ -8,6 +8,8 @@
 // This only works on Linux
 #ifdef LINUX
 #include <termios.h>
+#include <fcntl.h>
+#include <unistd.h>
 #elif WIN32
 #include <windows.h>
 #include <strsafe.h>
@@ -255,7 +257,7 @@ ReturnValue_t ArduinoComIF::sendMessage(uint8_t command,
 	encodedLen = sizeof(sendBuffer) - remainingLen;
 
 #ifdef LINUX
-	ssize_t writtenlen = write(serialPort, sendBuffer, encodedLen);
+	ssize_t writtenlen = ::write(serialPort, sendBuffer, encodedLen);
 	if (writtenlen < 0) {
 		//we could try to find out what happened...
 		return RETURN_FAILED;
@@ -286,7 +288,7 @@ void ArduinoComIF::handleSerialPortRx() {
 
 	rxBuffer.writeData(dataFromSerial, bytesRead);
 
-	uint8_t dataReceivedSoFar[rxBuffer.maxSize()];
+	uint8_t dataReceivedSoFar[rxBuffer.getMaxSize()];
 
 	uint32_t dataLenReceivedSoFar = 0;
 
@@ -296,11 +298,11 @@ void ArduinoComIF::handleSerialPortRx() {
 	//look for STX
 	size_t firstSTXinRawData = 0;
 	while ((firstSTXinRawData < dataLenReceivedSoFar)
-			&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX)) {
+			&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR)) {
 		firstSTXinRawData++;
 	}
 
-	if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX) {
+	if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX_CHAR) {
 		//there is no STX in our data, throw it away...
 		rxBuffer.deleteData(dataLenReceivedSoFar);
 		return;

bsp_hosted/comIF/ArduinoCookie.cpp

@@ -1,4 +1,4 @@
-#include "ArduinoCookie.h"
+#include <bsp_hosted/comIF/ArduinoCookie.h>
 
 ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address,
 		const size_t maxReplySize) :

bsp_hosted/comIF/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${TARGET_NAME} PUBLIC
+	ArduinoComIF.cpp
+	ArduinoCookie.cpp
+)
+
+
+
+

bsp_hosted/fsfwconfig/CMakeLists.txt

@@ -0,0 +1,21 @@
+target_sources(${TARGET_NAME} PRIVATE
+	ipc/MissionMessageTypes.cpp
+)
+
+target_include_directories(${TARGET_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
+        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
+        events/translateEvents.cpp
+    )
+endif()

bsp_hosted/fsfwconfig/FSFWConfig.h.in

@@ -0,0 +1,75 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <cstddef>
+#include <cstdint>
+
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
+#define FSFW_CPP_OSTREAM_ENABLED 	1
+
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL			1
+
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
+	#define FSFW_DISABLE_PRINTOUT 	0
+#endif
+
+#define FSFW_USE_PUS_C_TELEMETRY    1
+#define FSFW_USE_PUS_C_TELECOMMANDS 1
+
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT 		1
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION	1
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO				1
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
+#else
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO 	            1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE          0
+
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX 0
+
+namespace fsfwconfig {
+
+//! Default timestamp size. The default timestamp will be an seven byte CDC short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 7;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simultaneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
+
+static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
+
+}
+
+#endif /* CONFIG_FSFWCONFIG_H_ */

bsp_hosted/fsfwconfig/OBSWConfig.h.in

@@ -0,0 +1,32 @@
+/**
+ * @brief	This file can be used to add preprocessor define for conditional
+ * 			code inclusion exclusion or various other project constants and
+ * 			properties in one place.
+ */
+#ifndef CONFIG_OBSWCONFIG_H_
+#define CONFIG_OBSWCONFIG_H_
+
+#include "commonConfig.h"
+
+#define OBSW_ADD_TEST_CODE      1
+
+/* These defines should be disabled for mission code but are useful for
+debugging. */
+#define OBSW_VEBOSE_LEVEL       1
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CONFIG_OBSWCONFIG_H_ */

bsp_hosted/fsfwconfig/devices/gpioIds.h

@@ -0,0 +1,59 @@
+#ifndef FSFWCONFIG_DEVICES_GPIOIDS_H_
+#define FSFWCONFIG_DEVICES_GPIOIDS_H_
+
+#include <linux/gpio/GpioIF.h>
+
+namespace gpioIds {
+	enum gpioId_t {
+		HEATER_0,
+		HEATER_1,
+		HEATER_2,
+		HEATER_3,
+		HEATER_4,
+		HEATER_5,
+		HEATER_6,
+		HEATER_7,
+		DEPLSA1,
+		DEPLSA2,
+
+		MGM_0_LIS3_CS,
+		MGM_1_RM3100_CS,
+		GYRO_0_ADIS_CS,
+		GYRO_1_L3G_CS,
+		GYRO_2_L3G_CS,
+		MGM_2_LIS3_CS,
+		MGM_3_RM3100_CS,
+
+		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,
+
+        SPI_MUX_BIT_1,
+        SPI_MUX_BIT_2,
+        SPI_MUX_BIT_3,
+        SPI_MUX_BIT_4,
+        SPI_MUX_BIT_5,
+        SPI_MUX_BIT_6
+	};
+}
+
+
+
+
+#endif /* FSFWCONFIG_DEVICES_GPIOIDS_H_ */

bsp_hosted/fsfwconfig/devices/powerSwitcherList.h

@@ -0,0 +1,58 @@
+#ifndef FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+#include <OBSWConfig.h>
+
+namespace pcduSwitches {
+	/* Switches are uint8_t datatype and go from 0 to 255 */
+	enum switcherList {
+	    Q7S,
+        PAYLOAD_PCDU_CH1,
+        RW,
+        TCS_BOARD_8V_HEATER_IN,
+        SUS_REDUNDANT,
+        DEPLOYMENT_MECHANISM,
+        PAYLOAD_PCDU_CH6,
+        ACS_BOARD_SIDE_B,
+        PAYLOAD_CAMERA,
+        TCS_BOARD_3V3,
+        SYRLINKS,
+        STAR_TRACKER,
+        MGT,
+        SUS_NOMINAL,
+        SOLAR_CELL_EXP,
+        PLOC,
+        ACS_BORAD_SIDE_A,
+        NUMBER_OF_SWITCHES
+	};
+
+	static const uint8_t ON = 1;
+	static const uint8_t OFF = 0;
+
+	/* Output states after reboot of the PDUs */
+	static const uint8_t INIT_STATE_Q7S = ON;
+	static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH1 = OFF;
+	static const uint8_t INIT_STATE_RW = OFF;
+#if TE0720 == 1
+	/* Because the TE0720 is not connected to the PCDU, this switch is always on */
+	static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = ON;
+#else
+	static const uint8_t INIT_STATE_TCS_BOARD_8V_HEATER_IN = OFF;
+#endif
+	static const uint8_t INIT_STATE_SUS_REDUNDANT = OFF;
+	static const uint8_t INIT_STATE_DEPLOYMENT_MECHANISM = OFF;
+	static const uint8_t INIT_STATE_PAYLOAD_PCDU_CH6 = OFF;
+	static const uint8_t INIT_STATE_ACS_BOARD_SIDE_B = OFF;
+	static const uint8_t INIT_STATE_PAYLOAD_CAMERA = OFF;
+	static const uint8_t INIT_STATE_TCS_BOARD_3V3 = OFF;
+	static const uint8_t INIT_STATE_SYRLINKS = OFF;
+	static const uint8_t INIT_STATE_STAR_TRACKER = OFF;
+	static const uint8_t INIT_STATE_MGT = OFF;
+	static const uint8_t INIT_STATE_SUS_NOMINAL = OFF;
+	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;
+}
+
+
+#endif /* FSFWCONFIG_DEVICES_POWERSWITCHERLIST_H_ */

bsp_hosted/fsfwconfig/events/subsystemIdRanges.h

@@ -1,7 +1,7 @@
 #ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 
-#include <fsfw/events/fwSubsystemIdRanges.h>
+#include <common/config/commonSubsystemIds.h>
 #include <cstdint>
 
 /**
@@ -10,16 +10,7 @@
  */
 namespace SUBSYSTEM_ID {
 enum: uint8_t {
-	SUBSYSTE_ID_START = FW_SUBSYSTEM_ID_RANGE,
-	PUS_SERVICE_2,
-	PUS_SERVICE_3,
-	PUS_SERVICE_5,
-	PUS_SERVICE_6,
-	PUS_SERVICE_8,
-	PUS_SERVICE_23,
-	MGM_LIS3MDL,
-
-	DUMMY_DEVICE,
+	SUBSYSTEM_ID_START = COMMON_SUBSYSTEM_ID_END
 };
 }
 

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -0,0 +1,264 @@
+/**
+ * @brief    Auto-generated event translation file. Contains 83 translations.
+ * @details
+ * Generated on: 2021-05-17 19:49:55
+ */
+#include "translateEvents.h"
+
+const char *STORE_SEND_WRITE_FAILED_STRING = "STORE_SEND_WRITE_FAILED";
+const char *STORE_WRITE_FAILED_STRING = "STORE_WRITE_FAILED";
+const char *STORE_SEND_READ_FAILED_STRING = "STORE_SEND_READ_FAILED";
+const char *STORE_READ_FAILED_STRING = "STORE_READ_FAILED";
+const char *UNEXPECTED_MSG_STRING = "UNEXPECTED_MSG";
+const char *STORING_FAILED_STRING = "STORING_FAILED";
+const char *TM_DUMP_FAILED_STRING = "TM_DUMP_FAILED";
+const char *STORE_INIT_FAILED_STRING = "STORE_INIT_FAILED";
+const char *STORE_INIT_EMPTY_STRING = "STORE_INIT_EMPTY";
+const char *STORE_CONTENT_CORRUPTED_STRING = "STORE_CONTENT_CORRUPTED";
+const char *STORE_INITIALIZE_STRING = "STORE_INITIALIZE";
+const char *INIT_DONE_STRING = "INIT_DONE";
+const char *DUMP_FINISHED_STRING = "DUMP_FINISHED";
+const char *DELETION_FINISHED_STRING = "DELETION_FINISHED";
+const char *DELETION_FAILED_STRING = "DELETION_FAILED";
+const char *AUTO_CATALOGS_SENDING_FAILED_STRING = "AUTO_CATALOGS_SENDING_FAILED";
+const char *GET_DATA_FAILED_STRING = "GET_DATA_FAILED";
+const char *STORE_DATA_FAILED_STRING = "STORE_DATA_FAILED";
+const char *DEVICE_BUILDING_COMMAND_FAILED_STRING = "DEVICE_BUILDING_COMMAND_FAILED";
+const char *DEVICE_SENDING_COMMAND_FAILED_STRING = "DEVICE_SENDING_COMMAND_FAILED";
+const char *DEVICE_REQUESTING_REPLY_FAILED_STRING = "DEVICE_REQUESTING_REPLY_FAILED";
+const char *DEVICE_READING_REPLY_FAILED_STRING = "DEVICE_READING_REPLY_FAILED";
+const char *DEVICE_INTERPRETING_REPLY_FAILED_STRING = "DEVICE_INTERPRETING_REPLY_FAILED";
+const char *DEVICE_MISSED_REPLY_STRING = "DEVICE_MISSED_REPLY";
+const char *DEVICE_UNKNOWN_REPLY_STRING = "DEVICE_UNKNOWN_REPLY";
+const char *DEVICE_UNREQUESTED_REPLY_STRING = "DEVICE_UNREQUESTED_REPLY";
+const char *INVALID_DEVICE_COMMAND_STRING = "INVALID_DEVICE_COMMAND";
+const char *MONITORING_LIMIT_EXCEEDED_STRING = "MONITORING_LIMIT_EXCEEDED";
+const char *MONITORING_AMBIGUOUS_STRING = "MONITORING_AMBIGUOUS";
+const char *FUSE_CURRENT_HIGH_STRING = "FUSE_CURRENT_HIGH";
+const char *FUSE_WENT_OFF_STRING = "FUSE_WENT_OFF";
+const char *POWER_ABOVE_HIGH_LIMIT_STRING = "POWER_ABOVE_HIGH_LIMIT";
+const char *POWER_BELOW_LOW_LIMIT_STRING = "POWER_BELOW_LOW_LIMIT";
+const char *SWITCH_WENT_OFF_STRING = "SWITCH_WENT_OFF";
+const char *HEATER_ON_STRING = "HEATER_ON";
+const char *HEATER_OFF_STRING = "HEATER_OFF";
+const char *HEATER_TIMEOUT_STRING = "HEATER_TIMEOUT";
+const char *HEATER_STAYED_ON_STRING = "HEATER_STAYED_ON";
+const char *HEATER_STAYED_OFF_STRING = "HEATER_STAYED_OFF";
+const char *TEMP_SENSOR_HIGH_STRING = "TEMP_SENSOR_HIGH";
+const char *TEMP_SENSOR_LOW_STRING = "TEMP_SENSOR_LOW";
+const char *TEMP_SENSOR_GRADIENT_STRING = "TEMP_SENSOR_GRADIENT";
+const char *COMPONENT_TEMP_LOW_STRING = "COMPONENT_TEMP_LOW";
+const char *COMPONENT_TEMP_HIGH_STRING = "COMPONENT_TEMP_HIGH";
+const char *COMPONENT_TEMP_OOL_LOW_STRING = "COMPONENT_TEMP_OOL_LOW";
+const char *COMPONENT_TEMP_OOL_HIGH_STRING = "COMPONENT_TEMP_OOL_HIGH";
+const char *TEMP_NOT_IN_OP_RANGE_STRING = "TEMP_NOT_IN_OP_RANGE";
+const char *FDIR_CHANGED_STATE_STRING = "FDIR_CHANGED_STATE";
+const char *FDIR_STARTS_RECOVERY_STRING = "FDIR_STARTS_RECOVERY";
+const char *FDIR_TURNS_OFF_DEVICE_STRING = "FDIR_TURNS_OFF_DEVICE";
+const char *MONITOR_CHANGED_STATE_STRING = "MONITOR_CHANGED_STATE";
+const char *VALUE_BELOW_LOW_LIMIT_STRING = "VALUE_BELOW_LOW_LIMIT";
+const char *VALUE_ABOVE_HIGH_LIMIT_STRING = "VALUE_ABOVE_HIGH_LIMIT";
+const char *VALUE_OUT_OF_RANGE_STRING = "VALUE_OUT_OF_RANGE";
+const char *SWITCHING_TM_FAILED_STRING = "SWITCHING_TM_FAILED";
+const char *CHANGING_MODE_STRING = "CHANGING_MODE";
+const char *MODE_INFO_STRING = "MODE_INFO";
+const char *FALLBACK_FAILED_STRING = "FALLBACK_FAILED";
+const char *MODE_TRANSITION_FAILED_STRING = "MODE_TRANSITION_FAILED";
+const char *CANT_KEEP_MODE_STRING = "CANT_KEEP_MODE";
+const char *OBJECT_IN_INVALID_MODE_STRING = "OBJECT_IN_INVALID_MODE";
+const char *FORCING_MODE_STRING = "FORCING_MODE";
+const char *MODE_CMD_REJECTED_STRING = "MODE_CMD_REJECTED";
+const char *HEALTH_INFO_STRING = "HEALTH_INFO";
+const char *CHILD_CHANGED_HEALTH_STRING = "CHILD_CHANGED_HEALTH";
+const char *CHILD_PROBLEMS_STRING = "CHILD_PROBLEMS";
+const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
+const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
+const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
+const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
+const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
+const char *RF_LOST_STRING = "RF_LOST";
+const char *BIT_LOCK_STRING = "BIT_LOCK";
+const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
+const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
+const char *CLOCK_SET_STRING = "CLOCK_SET";
+const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *TEST_STRING = "TEST";
+const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
+const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE";
+const char *ACK_FAILURE_STRING = "ACK_FAILURE";
+const char *EXE_FAILURE_STRING = "EXE_FAILURE";
+const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
+
+const char * translateEvents(Event event) {
+	switch( (event & 0xffff) ) {
+	case(2200):
+		return STORE_SEND_WRITE_FAILED_STRING;
+	case(2201):
+		return STORE_WRITE_FAILED_STRING;
+	case(2202):
+		return STORE_SEND_READ_FAILED_STRING;
+	case(2203):
+		return STORE_READ_FAILED_STRING;
+	case(2204):
+		return UNEXPECTED_MSG_STRING;
+	case(2205):
+		return STORING_FAILED_STRING;
+	case(2206):
+		return TM_DUMP_FAILED_STRING;
+	case(2207):
+		return STORE_INIT_FAILED_STRING;
+	case(2208):
+		return STORE_INIT_EMPTY_STRING;
+	case(2209):
+		return STORE_CONTENT_CORRUPTED_STRING;
+	case(2210):
+		return STORE_INITIALIZE_STRING;
+	case(2211):
+		return INIT_DONE_STRING;
+	case(2212):
+		return DUMP_FINISHED_STRING;
+	case(2213):
+		return DELETION_FINISHED_STRING;
+	case(2214):
+		return DELETION_FAILED_STRING;
+	case(2215):
+		return AUTO_CATALOGS_SENDING_FAILED_STRING;
+	case(2600):
+		return GET_DATA_FAILED_STRING;
+	case(2601):
+		return STORE_DATA_FAILED_STRING;
+	case(2800):
+		return DEVICE_BUILDING_COMMAND_FAILED_STRING;
+	case(2801):
+		return DEVICE_SENDING_COMMAND_FAILED_STRING;
+	case(2802):
+		return DEVICE_REQUESTING_REPLY_FAILED_STRING;
+	case(2803):
+		return DEVICE_READING_REPLY_FAILED_STRING;
+	case(2804):
+		return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
+	case(2805):
+		return DEVICE_MISSED_REPLY_STRING;
+	case(2806):
+		return DEVICE_UNKNOWN_REPLY_STRING;
+	case(2807):
+		return DEVICE_UNREQUESTED_REPLY_STRING;
+	case(2808):
+		return INVALID_DEVICE_COMMAND_STRING;
+	case(2809):
+		return MONITORING_LIMIT_EXCEEDED_STRING;
+	case(2810):
+		return MONITORING_AMBIGUOUS_STRING;
+	case(4201):
+		return FUSE_CURRENT_HIGH_STRING;
+	case(4202):
+		return FUSE_WENT_OFF_STRING;
+	case(4204):
+		return POWER_ABOVE_HIGH_LIMIT_STRING;
+	case(4205):
+		return POWER_BELOW_LOW_LIMIT_STRING;
+	case(4300):
+		return SWITCH_WENT_OFF_STRING;
+	case(5000):
+		return HEATER_ON_STRING;
+	case(5001):
+		return HEATER_OFF_STRING;
+	case(5002):
+		return HEATER_TIMEOUT_STRING;
+	case(5003):
+		return HEATER_STAYED_ON_STRING;
+	case(5004):
+		return HEATER_STAYED_OFF_STRING;
+	case(5200):
+		return TEMP_SENSOR_HIGH_STRING;
+	case(5201):
+		return TEMP_SENSOR_LOW_STRING;
+	case(5202):
+		return TEMP_SENSOR_GRADIENT_STRING;
+	case(5901):
+		return COMPONENT_TEMP_LOW_STRING;
+	case(5902):
+		return COMPONENT_TEMP_HIGH_STRING;
+	case(5903):
+		return COMPONENT_TEMP_OOL_LOW_STRING;
+	case(5904):
+		return COMPONENT_TEMP_OOL_HIGH_STRING;
+	case(5905):
+		return TEMP_NOT_IN_OP_RANGE_STRING;
+	case(7101):
+		return FDIR_CHANGED_STATE_STRING;
+	case(7102):
+		return FDIR_STARTS_RECOVERY_STRING;
+	case(7103):
+		return FDIR_TURNS_OFF_DEVICE_STRING;
+	case(7201):
+		return MONITOR_CHANGED_STATE_STRING;
+	case(7202):
+		return VALUE_BELOW_LOW_LIMIT_STRING;
+	case(7203):
+		return VALUE_ABOVE_HIGH_LIMIT_STRING;
+	case(7204):
+		return VALUE_OUT_OF_RANGE_STRING;
+	case(7301):
+		return SWITCHING_TM_FAILED_STRING;
+	case(7400):
+		return CHANGING_MODE_STRING;
+	case(7401):
+		return MODE_INFO_STRING;
+	case(7402):
+		return FALLBACK_FAILED_STRING;
+	case(7403):
+		return MODE_TRANSITION_FAILED_STRING;
+	case(7404):
+		return CANT_KEEP_MODE_STRING;
+	case(7405):
+		return OBJECT_IN_INVALID_MODE_STRING;
+	case(7406):
+		return FORCING_MODE_STRING;
+	case(7407):
+		return MODE_CMD_REJECTED_STRING;
+	case(7506):
+		return HEALTH_INFO_STRING;
+	case(7507):
+		return CHILD_CHANGED_HEALTH_STRING;
+	case(7508):
+		return CHILD_PROBLEMS_STRING;
+	case(7509):
+		return OVERWRITING_HEALTH_STRING;
+	case(7510):
+		return TRYING_RECOVERY_STRING;
+	case(7511):
+		return RECOVERY_STEP_STRING;
+	case(7512):
+		return RECOVERY_DONE_STRING;
+	case(7900):
+		return RF_AVAILABLE_STRING;
+	case(7901):
+		return RF_LOST_STRING;
+	case(7902):
+		return BIT_LOCK_STRING;
+	case(7903):
+		return BIT_LOCK_LOST_STRING;
+	case(7905):
+		return FRAME_PROCESSING_FAILED_STRING;
+	case(8900):
+		return CLOCK_SET_STRING;
+	case(8901):
+		return CLOCK_SET_FAILURE_STRING;
+	case(9700):
+		return TEST_STRING;
+	case(10600):
+		return CHANGE_OF_SETUP_PARAMETER_STRING;
+	case(11101):
+		return MEMORY_READ_RPT_CRC_FAILURE_STRING;
+	case(11102):
+		return ACK_FAILURE_STRING;
+	case(11103):
+		return EXE_FAILURE_STRING;
+	case(11104):
+		return CRC_FAILURE_EVENT_STRING;
+	default:
+		return "UNKNOWN_EVENT";
+	}
+	return 0;
+}

bsp_hosted/fsfwconfig/events/translateEvents.h

@@ -1,10 +1,3 @@
-/*
- * translateEvent.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
 #ifndef FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
 #define FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_
 
@@ -12,5 +5,4 @@
 
 const char * translateEvents(Event event);
 
-
 #endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */

bsp_hosted/fsfwconfig/fsfwconfig.mk

@@ -0,0 +1,7 @@
+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,5 +1,5 @@
+#include "MissionMessageTypes.h"
 #include <fsfw/ipc/CommandMessage.h>
-#include <hosted/fsfwconfig/ipc/MissionMessageTypes.h>
 
 void messagetypes::clearMissionMessage(CommandMessage* message) {
 	switch(message->getMessageType()) {

bsp_hosted/fsfwconfig/ipc/MissionMessageTypes.h

@@ -11,7 +11,7 @@ class CommandMessage;
  * <fsfw/ipc/FwMessageTypes.h>
  * @param message Generic Command Message
  */
-namespace messagetypes{
+namespace messagetypes {
 enum MESSAGE_TYPE {
 	MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
 };

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -2,15 +2,11 @@
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
 #include <cstdint>
+#include <commonObjects.h>
 
 // The objects will be instantiated in the ID order
 namespace objects {
 	enum sourceObjects: uint32_t {
-		/* First Byte 0x50-0x52 reserved for PUS Services **/
-		CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-		PUS_PACKET_DISTRIBUTOR = 0x50000200,
-		UDP_BRIDGE = 0x50000300,
-		UDP_POLLING_TASK = 0x50000400,
 
 		PUS_SERVICE_3 = 0x51000300,
 		PUS_SERVICE_5 = 0x51000400,
@@ -19,7 +15,6 @@ namespace objects {
 		PUS_SERVICE_23 = 0x51002300,
 		PUS_SERVICE_201 = 0x51020100,
 
-		TIME_STAMPER = 0x52000001,
 		TM_FUNNEL = 0x52000002,
 
 		/* Test Task */

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -0,0 +1,109 @@
+/** 
+ * @brief	Auto-generated object translation file.
+ * @details
+ * Contains 31 translations.
+ * Generated on: 2021-05-17 19:12:49
+ */
+#include "translateObjects.h"
+
+const char *TEST_TASK_STRING = "TEST_TASK";
+const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
+const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
+const char *PUS_SERVICE_3_STRING = "PUS_SERVICE_3";
+const char *PUS_SERVICE_5_STRING = "PUS_SERVICE_5";
+const char *PUS_SERVICE_6_STRING = "PUS_SERVICE_6";
+const char *PUS_SERVICE_8_STRING = "PUS_SERVICE_8";
+const char *PUS_SERVICE_23_STRING = "PUS_SERVICE_23";
+const char *PUS_SERVICE_201_STRING = "PUS_SERVICE_201";
+const char *TM_FUNNEL_STRING = "TM_FUNNEL";
+const char *FSFW_OBJECTS_START_STRING = "FSFW_OBJECTS_START";
+const char *PUS_SERVICE_1_VERIFICATION_STRING = "PUS_SERVICE_1_VERIFICATION";
+const char *PUS_SERVICE_2_DEVICE_ACCESS_STRING = "PUS_SERVICE_2_DEVICE_ACCESS";
+const char *PUS_SERVICE_3_HOUSEKEEPING_STRING = "PUS_SERVICE_3_HOUSEKEEPING";
+const char *PUS_SERVICE_5_EVENT_REPORTING_STRING = "PUS_SERVICE_5_EVENT_REPORTING";
+const char *PUS_SERVICE_8_FUNCTION_MGMT_STRING = "PUS_SERVICE_8_FUNCTION_MGMT";
+const char *PUS_SERVICE_9_TIME_MGMT_STRING = "PUS_SERVICE_9_TIME_MGMT";
+const char *PUS_SERVICE_17_TEST_STRING = "PUS_SERVICE_17_TEST";
+const char *PUS_SERVICE_20_PARAMETERS_STRING = "PUS_SERVICE_20_PARAMETERS";
+const char *PUS_SERVICE_200_MODE_MGMT_STRING = "PUS_SERVICE_200_MODE_MGMT";
+const char *HEALTH_TABLE_STRING = "HEALTH_TABLE";
+const char *MODE_STORE_STRING = "MODE_STORE";
+const char *EVENT_MANAGER_STRING = "EVENT_MANAGER";
+const char *INTERNAL_ERROR_REPORTER_STRING = "INTERNAL_ERROR_REPORTER";
+const char *TC_STORE_STRING = "TC_STORE";
+const char *TM_STORE_STRING = "TM_STORE";
+const char *IPC_STORE_STRING = "IPC_STORE";
+const char *TIME_STAMPER_STRING = "TIME_STAMPER";
+const char *FSFW_OBJECTS_END_STRING = "FSFW_OBJECTS_END";
+const char *DUMMY_INTERFACE_STRING = "DUMMY_INTERFACE";
+const char *NO_OBJECT_STRING = "NO_OBJECT";
+
+const char* translateObject(object_id_t object) {
+	switch( (object & 0xFFFFFFFF) ) {
+	case 0x42694269:
+		return TEST_TASK_STRING;
+	case 0x4400AFFE:
+		return DUMMY_HANDLER_STRING;
+	case 0x49000001:
+		return ARDUINO_COM_IF_STRING;
+	case 0x51000300:
+		return PUS_SERVICE_3_STRING;
+	case 0x51000400:
+		return PUS_SERVICE_5_STRING;
+	case 0x51000500:
+		return PUS_SERVICE_6_STRING;
+	case 0x51000800:
+		return PUS_SERVICE_8_STRING;
+	case 0x51002300:
+		return PUS_SERVICE_23_STRING;
+	case 0x51020100:
+		return PUS_SERVICE_201_STRING;
+	case 0x52000002:
+		return TM_FUNNEL_STRING;
+	case 0x53000000:
+		return FSFW_OBJECTS_START_STRING;
+	case 0x53000001:
+		return PUS_SERVICE_1_VERIFICATION_STRING;
+	case 0x53000002:
+		return PUS_SERVICE_2_DEVICE_ACCESS_STRING;
+	case 0x53000003:
+		return PUS_SERVICE_3_HOUSEKEEPING_STRING;
+	case 0x53000005:
+		return PUS_SERVICE_5_EVENT_REPORTING_STRING;
+	case 0x53000008:
+		return PUS_SERVICE_8_FUNCTION_MGMT_STRING;
+	case 0x53000009:
+		return PUS_SERVICE_9_TIME_MGMT_STRING;
+	case 0x53000017:
+		return PUS_SERVICE_17_TEST_STRING;
+	case 0x53000020:
+		return PUS_SERVICE_20_PARAMETERS_STRING;
+	case 0x53000200:
+		return PUS_SERVICE_200_MODE_MGMT_STRING;
+	case 0x53010000:
+		return HEALTH_TABLE_STRING;
+	case 0x53010100:
+		return MODE_STORE_STRING;
+	case 0x53030000:
+		return EVENT_MANAGER_STRING;
+	case 0x53040000:
+		return INTERNAL_ERROR_REPORTER_STRING;
+	case 0x534f0100:
+		return TC_STORE_STRING;
+	case 0x534f0200:
+		return TM_STORE_STRING;
+	case 0x534f0300:
+		return IPC_STORE_STRING;
+	case 0x53500010:
+		return TIME_STAMPER_STRING;
+	case 0x53ffffff:
+		return FSFW_OBJECTS_END_STRING;
+	case 0xCAFECAFE:
+		return DUMMY_INTERFACE_STRING;
+	case 0xFFFFFFFF:
+		return NO_OBJECT_STRING;
+	default:
+		return "UNKNOWN_OBJECT";
+	}
+	return 0;
+}

bsp_hosted/fsfwconfig/objects/translateObjects.h

@@ -1,16 +1,8 @@
-/*
- * translateObjects.h
- *
- *  Created on: 28 May 2019
- *      Author: Robin
- */
-
 #ifndef FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_
 #define FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_
 
-#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/objectmanager/SystemObjectIF.h>
 
 const char* translateObject(object_id_t object);
 
-
 #endif /* FSFWCONFIG_OBJECTS_TRANSLATEOBJECTS_H_ */

bsp_hosted/fsfwconfig/returnvalues/classIds.h

@@ -1,6 +1,7 @@
 #ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
 #define CONFIG_RETURNVALUES_CLASSIDS_H_
 
+#include "commonClassIds.h"
 #include <fsfw/returnvalues/FwClassIds.h>
 
 /**
@@ -10,8 +11,7 @@
  */
 namespace CLASS_ID {
 enum {
-	MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
-	MGM_LIS3MDL
+	CLASS_ID_START = COMMON_CLASS_ID_END,
 };
 }
 

bsp_hosted/main.cpp

@@ -1,7 +1,7 @@
-#include <bsp_linux/InitMission.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <hosted/fsfwconfig/OBSWVersion.h>
+#include "InitMission.h"
 
+#include <OBSWVersion.h>
+#include <fsfw/tasks/TaskFactory.h>
 #include <iostream>
 
 #ifdef WIN32
@@ -24,7 +24,7 @@ int main(void)
             << SW_SUBVERSION << "." << SW_SUBSUBVERSION << " -- " << std::endl;
     std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
 
-	InitMission::initMission();
+	initmission::initMission();
 
 	for(;;) {
 		// suspend main thread by sleeping it.

bsp_linux/InitMission.cpp

@@ -1,159 +0,0 @@
-#include <bsp_linux/InitMission.h>
-#include <bsp_linux/ObjectFactory.h>
-
-#include <fsfw/objectmanager/ObjectManagerIF.h>
-#include <fsfw/returnvalues/HasReturnvaluesIF.h>
-#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
-#include <fsfw/datapool/DataPool.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/tasks/FixedTimeslotTaskIF.h>
-#include <fsfw/tasks/PeriodicTaskIF.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfwconfig/objects/systemObjectList.h>
-#include <fsfwconfig/OBSWConfig.h>
-
-#include <iostream>
-
-// This is configured for linux without \cr
-#ifdef LINUX
-ServiceInterfaceStream sif::debug("DEBUG");
-ServiceInterfaceStream sif::info("INFO");
-ServiceInterfaceStream sif::warning("WARNING");
-ServiceInterfaceStream sif::error("ERROR", false, false, true);
-#else
-ServiceInterfaceStream sif::debug("DEBUG", true);
-ServiceInterfaceStream sif::info("INFO", true);
-ServiceInterfaceStream sif::warning("WARNING", true);
-ServiceInterfaceStream sif::error("ERROR", true, false, true);
-#endif
-
-ObjectManagerIF *objectManager = nullptr;
-
-//Initialize Data Pool
-DataPool dataPool(nullptr);
-
-void InitMission::initMission() {
-	sif::info << "Building global objects.." << std::endl;
-	/* Instantiate global object manager and also create all objects */
-    objectManager = new ObjectManager(ObjectFactory::produce);
-    sif::info << "Initializing all objects.." << std::endl;
-    objectManager->initialize();
-
-    /* This function creates and starts all tasks */
-    initTasks();
-}
-
-void InitMission::initTasks(){
-	/* TMTC Distribution */
-	PeriodicTaskIF* TmTcDistributor = TaskFactory::instance()->
-			createPeriodicTask("DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE,
-					0.100, nullptr);
-	ReturnValue_t 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;
-    }
-
-    /* UDP bridge */
-    PeriodicTaskIF* UdpBridgeTask = TaskFactory::instance()->createPeriodicTask(
-    		"UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE,
-			0.2, nullptr);
-    result = UdpBridgeTask->addComponent(objects::UDP_BRIDGE);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-    	sif::error << "Add component UDP Unix Bridge failed" << std::endl;
-    }
-    PeriodicTaskIF* UdpPollingTask = TaskFactory::instance()->
-    		createPeriodicTask("UDP_POLLING", 80,
-    		PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, nullptr);
-    result = UdpPollingTask->addComponent(objects::UDP_POLLING_TASK);
-    if(result != HasReturnvaluesIF::RETURN_OK) {
-    	sif::error << "Add component UDP Polling failed" << std::endl;
-    }
-
-	/* PUS Services */
-	PeriodicTaskIF* PusVerification = TaskFactory::instance()->
-			createPeriodicTask("PUS_VERIF_1", 40,
-					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
-	result = PusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-
-	PeriodicTaskIF* PusEvents = TaskFactory::instance()->
-			createPeriodicTask("PUS_VERIF_1", 60,
-					PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, nullptr);
-	result = PusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-
-	PeriodicTaskIF* PusHighPrio = TaskFactory::instance()->
-			createPeriodicTask("PUS_HIGH_PRIO", 50,
-					PeriodicTaskIF::MINIMUM_STACK_SIZE,
-					0.200, nullptr);
-	result = PusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-	if(result!=HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-	result = PusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
-	if(result!=HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-
-	PeriodicTaskIF* PusMedPrio = TaskFactory::instance()->
-			createPeriodicTask("PUS_HIGH_PRIO", 40,
-					PeriodicTaskIF::MINIMUM_STACK_SIZE,
-					0.8, nullptr);
-	result = PusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
-	if(result!=HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-	result = PusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
-	if(result!=HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-
-	PeriodicTaskIF* PusLowPrio = TaskFactory::instance()->
-			createPeriodicTask("PUSB", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE,
-					1.6, nullptr);
-	result = PusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
-	if(result!=HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Object add component failed" << std::endl;
-	}
-
-
-#if ADD_TEST_CODE == 1
-	FixedTimeslotTaskIF* TestTimeslotTask = TaskFactory::instance()->
-			createFixedTimeslotTask("PST_TEST_TASK", 10,
-					PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
-	result = pst::pollingSequenceTestFunction(TestTimeslotTask);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::error << "InitMission::createTasks: Test PST initialization "
-				<< "failed!" << std::endl;
-	}
-#endif
-
-	//Main thread sleep
-	sif::info << "Starting tasks.." << std::endl;
-	TmTcDistributor->startTask();
-	UdpBridgeTask->startTask();
-	UdpPollingTask->startTask();
-
-	PusVerification->startTask();
-	PusEvents->startTask();
-	PusHighPrio->startTask();
-	PusMedPrio->startTask();
-	PusLowPrio->startTask();
-#if ADD_TEST_CODE == 1
-	TestTimeslotTask->startTask();
-#endif
-	sif::info << "Tasks started.." << std::endl;
-}

bsp_linux/bsp_linux.mk

@@ -1,4 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
-CSRC += $(wildcard $(CURRENTPATH)/*.c)
-
-CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c)

bsp_linux/comIF/ArduinoComIF.cpp

@@ -1,324 +0,0 @@
-#include "ArduinoCookie.h"
-#include "ArduinoComIF.h"
-
-#include <fsfw/globalfunctions/DleEncoder.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <fsfw/globalfunctions/CRC.h>
-
-#include <termios.h>
-
-ArduinoCommInterface::ArduinoCommInterface(object_id_t setObjectId,
-        const char *serialDevice) :
-		spiMap(MAX_NUMBER_OF_SPI_DEVICES), rxBuffer(
-				MAX_PACKET_SIZE * MAX_NUMBER_OF_SPI_DEVICES*10, true), SystemObject(setObjectId) {
-	initialized = false;
-	serialPort = ::open("/dev/ttyUSB0", O_RDWR);
-
-	if (serialPort < 0) {
-		//configuration error
-		printf("Error %i from open: %s\n", errno, strerror(errno));
-		return;
-	}
-
-	struct termios tty;
-	memset(&tty, 0, sizeof tty);
-
-	// Read in existing settings, and handle any error
-	if (tcgetattr(serialPort, &tty) != 0) {
-		printf("Error %i from tcgetattr: %s\n", errno, strerror(errno));
-		return;
-	}
-
-	tty.c_cflag &= ~PARENB; // Clear parity bit, disabling parity
-	tty.c_cflag &= ~CSTOPB; // Clear stop field, only one stop bit used in communication
-	tty.c_cflag |= CS8; // 8 bits per byte
-	tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
-	tty.c_lflag &= ~ICANON; //Disable Canonical Mode
-	tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
-	tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
-	tty.c_cc[VTIME] = 0;    // Non Blocking
-	tty.c_cc[VMIN] = 0;
-
-	cfsetispeed(&tty, B9600); //Baudrate
-
-	if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
-		//printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
-		return;
-	}
-
-	initialized = true;
-
-}
-
-ArduinoCommInterface::~ArduinoCommInterface() {
-	::close(serialPort);
-}
-
-ReturnValue_t ArduinoCommInterface::open(Cookie **cookie, uint32_t address,
-		uint32_t maxReplyLen) {
-	//This is a hack, will be gone with https://egit.irs.uni-stuttgart.de/fsfw/fsfw/issues/19
-	switch ((address >> 8) & 0xff) {
-	case 0:
-		*cookie = new ArduinoCookie(ArduinoCookie::SPI, address, maxReplyLen);
-		spiMap.insert(address, (ArduinoCookie*) *cookie); //Yes, I *do* know that it is an ArduinoSpiCookie, I just new'd it
-		break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ArduinoCommInterface::reOpen(Cookie *cookie, uint32_t address,
-		uint32_t maxReplyLen) {
-	//too lazy right now will be irrelevant with https://egit.irs.uni-stuttgart.de/fsfw/fsfw/issues/19
-	return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void ArduinoCommInterface::close(Cookie *cookie) {
-	//too lazy as well, find the correct Map, delete it there, then the cookie...
-}
-
-ReturnValue_t ArduinoCommInterface::sendMessage(Cookie *cookie, uint8_t *data,
-		uint32_t len) {
-	ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
-	if (arduinoCookie == NULL) {
-		return INVALID_COOKIE_TYPE;
-	}
-
-	return sendMessage(arduinoCookie->command, arduinoCookie->address, data,
-			len);
-}
-
-ReturnValue_t ArduinoCommInterface::getSendSuccess(Cookie *cookie) {
-	return RETURN_OK;
-}
-
-ReturnValue_t ArduinoCommInterface::requestReceiveMessage(Cookie *cookie) {
-	return RETURN_OK;
-}
-
-ReturnValue_t ArduinoCommInterface::readReceivedMessage(Cookie *cookie,
-		uint8_t **buffer, uint32_t *size) {
-
-	handleSerialPortRx();
-
-	ArduinoCookie *arduinoCookie = dynamic_cast<ArduinoCookie*>(cookie);
-	if (arduinoCookie == NULL) {
-		return INVALID_COOKIE_TYPE;
-	}
-
-	*buffer = arduinoCookie->replyBuffer;
-	*size = arduinoCookie->receivedDataLen;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t ArduinoCommInterface::setAddress(Cookie *cookie,
-		uint32_t address) {
-	//not implemented
-	return RETURN_FAILED;
-}
-
-uint32_t ArduinoCommInterface::getAddress(Cookie *cookie) {
-	//not implemented
-	return 0;
-}
-
-ReturnValue_t ArduinoCommInterface::setParameter(Cookie *cookie,
-		uint32_t parameter) {
-	//not implemented
-	return RETURN_FAILED;
-}
-
-uint32_t ArduinoCommInterface::getParameter(Cookie *cookie) {
-	//not implemented
-	return 0;
-}
-
-ReturnValue_t ArduinoCommInterface::sendMessage(uint8_t command,
-		uint8_t address, const uint8_t *data, size_t dataLen) {
-	if (dataLen > UINT16_MAX) {
-		return TOO_MUCH_DATA;
-	}
-
-	//being conservative here
-	uint8_t sendBuffer[(dataLen + 6) * 2 + 2];
-
-	sendBuffer[0] = DleEncoder::STX;
-
-	uint8_t *currentPosition = sendBuffer + 1;
-	size_t remainingLen = sizeof(sendBuffer) - 1;
-	uint32_t encodedLen;
-
-	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);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	uint8_t temporaryBuffer[2];
-
-	//note to Lukas: yes we _could_ use Serialize here, but for 16 bit it is a bit too much...
-	temporaryBuffer[0] = dataLen >> 8; //we checked dataLen above
-	temporaryBuffer[1] = dataLen;
-
-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	//encoding the actual data
-	result = DleEncoder::encode(data, dataLen, currentPosition, remainingLen,
-			&encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	uint16_t crc = CRC::crc16ccitt(&command, 1);
-	crc = CRC::crc16ccitt(&address, 1, crc);
-	//fortunately the length is still there
-	crc = CRC::crc16ccitt(temporaryBuffer, 2, crc);
-	crc = CRC::crc16ccitt(data, dataLen, crc);
-
-	temporaryBuffer[0] = crc >> 8;
-	temporaryBuffer[1] = crc;
-
-	result = DleEncoder::encode(temporaryBuffer, 2, currentPosition,
-			remainingLen, &encodedLen, false);
-	if (result != RETURN_OK) {
-		return result;
-	}
-	currentPosition += encodedLen;
-	remainingLen -= encodedLen; //DleEncoder will never return encodedLen > remainingLen
-
-	if (remainingLen > 0) {
-		*currentPosition = DleEncoder::ETX;
-	}
-	remainingLen -= 1;
-
-	encodedLen = sizeof(sendBuffer) - remainingLen;
-
-	ssize_t writtenlen = write(serialPort, sendBuffer, encodedLen);
-	if (writtenlen < 0) {
-		//we could try to find out what happened...
-		return RETURN_FAILED;
-	}
-	if (writtenlen != encodedLen) {
-		//the OS failed us, we do not try to block until everything is written, as
-		//we can not block the whole system here
-		return RETURN_FAILED;
-	}
-	return RETURN_OK;
-}
-
-void ArduinoCommInterface::handleSerialPortRx() {
-	uint32_t availableSpace = rxBuffer.availableWriteSpace();
-
-	uint8_t dataFromSerial[availableSpace];
-
-	ssize_t bytesRead = read(serialPort, dataFromSerial,
-			sizeof(dataFromSerial));
-
-	if (bytesRead < 0) {
-		return;
-	}
-
-	rxBuffer.writeData(dataFromSerial, bytesRead);
-
-	uint8_t dataReceivedSoFar[rxBuffer.maxSize()];
-
-	uint32_t dataLenReceivedSoFar = 0;
-
-	rxBuffer.readData(dataReceivedSoFar, sizeof(dataReceivedSoFar), true,
-			&dataLenReceivedSoFar);
-
-	//look for STX
-	size_t firstSTXinRawData = 0;
-	while ((firstSTXinRawData < dataLenReceivedSoFar)
-			&& (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX)) {
-		firstSTXinRawData++;
-	}
-
-	if (dataReceivedSoFar[firstSTXinRawData] != DleEncoder::STX) {
-		//there is no STX in our data, throw it away...
-		rxBuffer.deleteData(dataLenReceivedSoFar);
-		return;
-	}
-
-	uint8_t packet[MAX_PACKET_SIZE];
-	uint32_t packetLen;
-
-	uint32_t readSize;
-
-	ReturnValue_t result = DleEncoder::decode(
-			dataReceivedSoFar + firstSTXinRawData,
-			dataLenReceivedSoFar - firstSTXinRawData, &readSize, packet,
-			sizeof(packet), &packetLen);
-
-	size_t toDelete = firstSTXinRawData;
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		handlePacket(packet, packetLen);
-
-		//after handling the packet, we can delete it from the raw stream, it has been copied to packet
-		toDelete += readSize;
-	}
-
-	//remove Data which was processed
-	rxBuffer.deleteData(toDelete);
-}
-
-void ArduinoCommInterface::handlePacket(uint8_t *packet, size_t packetLen) {
-	uint16_t crc = CRC::crc16ccitt(packet, packetLen);
-	if (crc != 0) {
-		//CRC error
-		return;
-	}
-
-	uint8_t command = packet[0];
-	uint8_t address = packet[1];
-
-	uint16_t size = (packet[2] << 8) + packet[3];
-
-	if (size != packetLen - 6) {
-		//Invalid Length
-		return;
-	}
-
-	switch (command) {
-	case ArduinoCookie::SPI: {
-		ArduinoCookie **itsComplicated;
-		ReturnValue_t result = spiMap.find(address, &itsComplicated);
-		if (result != RETURN_OK) {
-			//we do no know this address
-			return;
-		}
-		ArduinoCookie *theActualCookie = *itsComplicated;
-		if (packetLen > theActualCookie->maxReplySize + 6) {
-			packetLen = theActualCookie->maxReplySize + 6;
-		}
-		memcpy(theActualCookie->replyBuffer, packet + 4, packetLen - 6);
-		theActualCookie->receivedDataLen = packetLen - 6;
-	}
-		break;
-	default:
-		return;
-	}
-}

bsp_linux/comIF/ArduinoComIF.h

@@ -1,73 +0,0 @@
-//#ifndef MISSION_ARDUINOCOMMINTERFACE_H_
-//#define MISSION_ARDUINOCOMMINTERFACE_H_
-//
-//#include <bits/stdint-uintn.h>
-//#include <framework/container/FixedMap.h>
-//#include <framework/container/SimpleRingBuffer.h>
-//#include <framework/devicehandlers/DeviceCommunicationIF.h>
-//#include <framework/returnvalues/HasReturnvaluesIF.h>
-//#include <stddef.h>
-//
-//#include "../../framework/objectmanager/SystemObject.h"
-//#include "ArduinoCookie.h"
-//
-////Forward declaration, so users don't peek
-//class ArduinoCookie;
-//
-//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;
-//
-//	static const uint8_t COMMAND_INVALID = -1;
-//	static const uint8_t COMMAND_SPI = 1;
-//
-//	ArduinoComIF(object_id_t setObjectId, const char *serialDevice);
-//	virtual ~ArduinoComIF();
-//
-//	virtual ReturnValue_t open(Cookie **cookie, uint32_t address,
-//			uint32_t maxReplyLen);
-//
-//	virtual ReturnValue_t reOpen(Cookie *cookie, uint32_t address,
-//			uint32_t maxReplyLen);
-//
-//	virtual void close(Cookie *cookie);
-//
-//	//SHOULDDO can data be const?
-//	virtual ReturnValue_t sendMessage(Cookie *cookie, uint8_t *data,
-//			uint32_t len);
-//
-//	virtual ReturnValue_t getSendSuccess(Cookie *cookie);
-//
-//	virtual ReturnValue_t requestReceiveMessage(Cookie *cookie);
-//
-//	virtual ReturnValue_t readReceivedMessage(Cookie *cookie, uint8_t **buffer,
-//			uint32_t *size);
-//
-//	virtual ReturnValue_t setAddress(Cookie *cookie, uint32_t address);
-//
-//	virtual uint32_t getAddress(Cookie *cookie);
-//
-//	virtual ReturnValue_t setParameter(Cookie *cookie, uint32_t parameter);
-//
-//	virtual uint32_t getParameter(Cookie *cookie);
-//private:
-//	//remembering if the initialization in the ctor worked
-//	//if not, all calls are disabled
-//	bool initialized;
-//	int serialPort;
-//	//used to know where to put the data if a reply is received
-//	FixedMap<uint8_t, ArduinoCookie*> spiMap;
-//
-//	SimpleRingBuffer rxBuffer;
-//
-//	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);
-//};
-//
-//#endif /* MISSION_ARDUINOCOMMINTERFACE_H_ */

bsp_linux/comIF/ArduinoCookie.cpp

@@ -1,12 +0,0 @@
-//#include <mission/Arduino/ArduinoCookie.h>
-//
-//ArduinoCookie::ArduinoCookie(Protocol_t protocol, uint8_t address,
-//		size_t maxReplySize) :
-//		command(protocol), address(address), receivedDataLen(0), maxReplySize(
-//				maxReplySize) {
-//	replyBuffer = new uint8_t[maxReplySize];
-//}
-//
-//ArduinoCookie::~ArduinoCookie() {
-//	delete[] replyBuffer;
-//}

bsp_linux/comIF/ArduinoCookie.h

@@ -1,25 +0,0 @@
-//#ifndef MISSION_ARDUINO_ARDUINOCOOKIE_H_
-//#define MISSION_ARDUINO_ARDUINOCOOKIE_H_
-//
-//#include <framework/devicehandlers/Cookie.h>
-//
-//#include <stdint.h>
-//#include <stdlib.h>
-//
-//class ArduinoCookie: public Cookie {
-//public:
-//	enum Protocol_t {
-//		INVALID = 0, SPI = 1
-//	};
-//	ArduinoCookie(Protocol_t protocol, uint8_t address, size_t maxReplySize);
-//	virtual ~ArduinoCookie();
-//
-//	uint8_t command;
-//	uint8_t address;
-//	uint8_t *replyBuffer;
-//	size_t receivedDataLen;
-//	size_t maxReplySize;
-//
-//};
-//
-//#endif /* MISSION_ARDUINO_ARDUINOCOOKIE_H_ */

bsp_linux_board/CMakeLists.txt

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

bsp_linux_board/Dockerfile

@@ -0,0 +1,37 @@
+FROM ubuntu:latest
+# FROM alpine:latest
+
+RUN apt-get update && apt-get install -y curl wget cmake g++
+
+# Raspberry Pi rootfs
+RUN mkdir -p /usr/rootfs; \
+    curl https://eive-cloud.irs.uni-stuttgart.de/index.php/s/kJe3nCnGPRGKFCz/download/rpi-rootfs.tar.gz /usr/rootfs \
+    | tar xvz -C /usr/rootfs
+# Raspberry Pi toolchain
+RUN mkdir -p /opt; \
+    cd /opt; \
+    wget https://github.com/Pro/raspi-toolchain/releases/latest/download/raspi-toolchain.tar.gz; \
+    tar xfz raspi-toolchain.tar.gz --strip-components=1 -C .; \
+    rm -rf raspi-toolchain.tar.gz
+
+# RUN apk add cmake make g++
+
+# Required for cmake build
+ENV RASPBERRY_VERSION="4"
+ENV RASPBIAN_ROOTFS="/usr/rootfs/rootfs"
+ENV PATH=$PATH:"/opt/cross-pi-gcc/bin"
+ENV CROSS_COMPILE="arm-linux-gnueabihf"
+
+WORKDIR /usr/src/app
+COPY . .
+
+RUN set -ex; \
+    rm -rf build-rpi; \
+    mkdir build-rpi; \
+    cd build-rpi; \
+    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux -DTGT_BSP="arm/raspberrypi" ..;
+
+ENTRYPOINT ["cmake", "--build", "build-rpi"]
+CMD ["-j"]
+# CMD ["bash"]
+

bsp_linux_board/InitMission.cpp

@@ -0,0 +1,192 @@
+#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/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 <iostream>
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+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);
+    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();
+    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);
+    ReturnValue_t 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;
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
+            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+    result = udpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "Add component UDP Unix Bridge failed" << std::endl;
+    }
+    PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
+            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+    result = udpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "Add component UDP Polling failed" << std::endl;
+    }
+
+    /* PUS Services */
+    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;
+    }
+
+    PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
+            "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+    result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+    if(result != HasReturnvaluesIF::RETURN_OK){
+        initmission::printAddObjectError("PUS5", objects::PUS_SERVICE_5_EVENT_REPORTING);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+    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);
+    }
+
+#if OBSW_ADD_TEST_PST == 1
+    FixedTimeslotTaskIF* pstTestTask = factory->createFixedTimeslotTask(
+            "ACS_PST", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 2.0, missedDeadlineFunc);
+    result = pst::pollingSequenceTest(pstTestTask);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "initmission::initTasks: ACS PST initialization failed!" << std::endl;
+    }
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+
+    PeriodicTaskIF* testTask = factory->createPeriodicTask(
+            "TEST_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+#if OBSW_ADD_TEST_CODE == 1
+    result = testTask->addComponent(objects::TEST_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+    }
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+#if RPI_ADD_SPI_TEST == 1
+    result = testTask->addComponent(objects::SPI_TEST);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+    }
+#endif /* RPI_ADD_SPI_TEST == 1 */
+#if RPI_ADD_GPIO_TEST == 1
+    result = testTask->addComponent(objects::LIBGPIOD_TEST);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
+    }
+#endif /* RPI_ADD_GPIO_TEST == 1 */
+#if RPI_ADD_UART_TEST == 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 */
+
+    sif::info << "Starting tasks.." << std::endl;
+    tmTcDistributor->startTask();
+    udpBridgeTask->startTask();
+    udpPollingTask->startTask();
+
+    pusVerification->startTask();
+    pusEvents->startTask();
+    pusHighPrio->startTask();
+    pusMedPrio->startTask();
+    pusLowPrio->startTask();
+
+#if OBSW_ADD_TEST_CODE == 1
+    testTask->startTask();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+
+#if OBSW_ADD_TEST_PST == 1
+    pstTestTask->startTask();
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+    sif::info << "Tasks started.." << std::endl;
+}

bsp_linux_board/InitMission.h

@@ -1,7 +1,7 @@
 #ifndef BSP_LINUX_INITMISSION_H_
 #define BSP_LINUX_INITMISSION_H_
 
-namespace InitMission {
+namespace initmission {
 void initMission();
 void initTasks();
 };

bsp_linux_board/ObjectFactory.cpp

@@ -0,0 +1,149 @@
+#include "ObjectFactory.h"
+
+#include "objects/systemObjectList.h"
+#include "devices/addresses.h"
+#include "devices/gpioIds.h"
+#include "OBSWConfig.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+#include "spiConf.h"
+
+#include "linux/boardtest/LibgpiodTest.h"
+#include "linux/boardtest/SpiTestClass.h"
+#include "linux/boardtest/UartTestClass.h"
+
+#include "mission/core/GenericFactory.h"
+#include "mission/utility/TmFunnel.h"
+#include "mission/devices/MGMHandlerLIS3MDL.h"
+#include "mission/devices/MGMHandlerRM3100.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"
+
+/* UDP server includes */
+#include "fsfw/osal/common/UdpTmTcBridge.h"
+#include "fsfw/osal/common/UdpTcPollingTask.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"
+
+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::UDP_BRIDGE;
+    // No storage object for now.
+    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();
+
+    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+
+    GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
+    GpioCookie* gpioCookie = nullptr;
+    static_cast<void>(gpioCookie);
+#if RPI_ADD_SPI_TEST == 1
+    new SpiTestClass(objects::SPI_TEST, gpioIF);
+#endif
+
+#if RPI_ADD_UART_TEST == 1
+    new UartTestClass(objects::UART_TEST);
+#endif
+
+#if RPI_LOOPBACK_TEST_GPIO == 1
+    GpioCookie* gpioCookieLoopback = new GpioCookie();
+    /* Loopback pins. Adapt according to setup */
+    gpioId_t gpioIdSender = gpioIds::TEST_ID_0;
+    int bcmPinSender = 26;
+    gpioId_t gpioIdReader = gpioIds::TEST_ID_1;
+    int bcmPinReader = 16;
+    gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdSender, bcmPinSender, "GPIO_LB_SENDER",
+            gpio::Direction::OUT, 0);
+    gpio::createRpiGpioConfig(gpioCookieLoopback, gpioIdReader, bcmPinReader, "GPIO_LB_READER",
+            gpio::Direction::IN, 0);
+    new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookieLoopback);
+#endif /* RPI_LOOPBACK_TEST_GPIO == 1 */
+
+    new SpiComIF(objects::SPI_COM_IF, gpioIF);
+
+    std::string spiDev;
+    SpiCookie* spiCookie = nullptr;
+    static_cast<void>(spiCookie);
+
+#if RPI_TEST_ACS_BOARD == 1
+    if(gpioCookie == nullptr) {
+        gpioCookie = new GpioCookie();
+    }
+    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_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_2_L3G_CS, gpio::GYRO_2_BCM_PIN,
+            "GYRO_2_L3G", gpio::Direction::OUT, 1);
+    gpioIF->addGpios(gpioCookie);
+
+    spiDev = "/dev/spidev0.0";
+    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 MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmLis3Handler->setStartUpImmediately();
+
+    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 MGMHandlerRM3100(objects::MGM_1_RM3100_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmRm3100Handler->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);
+    gyroL3gHandler->setStartUpImmediately();
+
+#endif /* RPI_TEST_ACS_BOARD == 1 */
+
+#if RPI_TEST_ADIS16507 == 1
+    if(gpioCookie == nullptr) {
+        gpioCookie = new GpioCookie();
+    }
+    gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
+            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
+    gpioIF->addGpios(gpioCookie);
+
+    spiDev = "/dev/spidev0.0";
+    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);
+    adisGyroHandler->setStartUpImmediately();
+#endif /* RPI_TEST_ADIS16507 == 1 */
+}

bsp_linux_board/ObjectFactory.h

@@ -1,17 +1,10 @@
-/*
- * ObjectFactory.h
- *
- *  Created on: Sep 22, 2020
- *      Author: steffen
- */
-
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_
 
 
 namespace ObjectFactory {
 	void setStatics();
-	void produce();
+	void produce(void* args);
 };
 
 #endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_linux_board/boardconfig/CMakeLists.txt

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

bsp_linux_board/boardconfig/print.c

@@ -1,4 +1,4 @@
-#include "print.h"
+#include <bsp_q7s/boardconfig/print.h>
 #include <stdio.h>
 
 void printChar(const char* character, bool errStream) {

bsp_linux_board/boardconfig/rpiConfig.h.in

@@ -0,0 +1,33 @@
+#ifndef BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+#define BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_
+
+#include <cstdint>
+
+#define RPI_ADD_GPIO_TEST               0
+#define RPI_LOOPBACK_TEST_GPIO          0
+
+#define RPI_TEST_ADIS16507              0
+
+// Only one of those 2 should be enabled!
+#define RPI_ADD_SPI_TEST                0
+#if RPI_ADD_SPI_TEST == 0
+#define RPI_TEST_ACS_BOARD              0
+#endif
+
+#define RPI_ADD_UART_TEST               1
+#if RPI_ADD_UART_TEST == 1
+#define RPI_TEST_GPS_DEVICE             0
+#endif
+
+/* Adapt these values accordingly */
+namespace gpio {
+static constexpr uint8_t MGM_0_BCM_PIN = 0;
+static constexpr uint8_t MGM_1_BCM_PIN = 1;
+static constexpr uint8_t MGM_2_BCM_PIN = 17;
+static constexpr uint8_t MGM_3_BCM_PIN = 27;
+static constexpr uint8_t GYRO_0_BCM_PIN = 5;
+static constexpr uint8_t GYRO_1_BCM_PIN = 6;
+static constexpr uint8_t GYRO_2_BCM_PIN = 4;
+}
+
+#endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */

bsp_linux_board/boardtest/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE
+)
+
+
+
+

bsp_linux_board/main.cpp

@@ -0,0 +1,36 @@
+#include "InitMission.h"
+#include <OBSWVersion.h>
+
+#include <fsfw/tasks/TaskFactory.h>
+
+#include <iostream>
+
+#ifdef RASPBERRY_PI
+static const char* const BOARD_NAME = "Raspberry Pi";
+#elif defined(BEAGLEBONEBLACK)
+static const char* const BOARD_NAME = "Beaglebone Black";
+#else
+static const char* const BOARD_NAME = "Unknown Board";
+#endif
+
+/**
+ * @brief 	    This is the main program and entry point for the Raspberry Pi.
+ * @return
+ */
+int main(void)
+{
+    std::cout << "-- EIVE OBSW --" << std::endl;
+    std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
+    std::cout << "-- Software version " << SW_NAME << " v" << SW_VERSION << "."
+    		<< SW_SUBVERSION << "." << SW_SUBSUBVERSION << " -- " << std::endl;
+    std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+	initmission::initMission();
+
+	for(;;) {
+		/* Suspend main thread by sleeping it. */
+		TaskFactory::delayTask(5000);
+	}
+}
+
+

bsp_q7s/CMakeLists.txt

@@ -0,0 +1,11 @@
+target_sources(${TARGET_NAME} PUBLIC
+	InitMission.cpp
+	main.cpp
+	ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)
+add_subdirectory(comIF)
+add_subdirectory(boardtest)
+add_subdirectory(gpio)
+add_subdirectory(core)

bsp_q7s/Dockerfile

@@ -0,0 +1,35 @@
+FROM ubuntu:latest
+# FROM alpine:latest
+
+ENV TZ=Europe/Berlin
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+RUN apt-get update && apt-get install -y curl cmake g++
+
+# Q7S root filesystem, required for cross-compilation. Use IPv6 for curl
+RUN mkdir -p /usr/rootfs; \
+    curl -6 https://eive-cloud.irs.uni-stuttgart.de/index.php/s/dnfMy9kGpgynN6J/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz \
+    | tar xvz -C /usr/rootfs
+# Q7S C++ cross-compiler. Use IPv6 for curl
+RUN mkdir -p /usr/tools; \
+    curl -6 https://eive-cloud.irs.uni-stuttgart.de/index.php/s/RMsbHydJc6PSqcz/download/gcc-arm-linux-gnueabi.tar.gz \
+    | tar xvz -C /usr/tools
+
+# RUN apk add cmake make g++
+
+# Required for cmake build
+ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
+ENV PATH=$PATH:"/usr/tools/gcc-arm-linux-gnueabi/bin"
+
+WORKDIR /usr/src/app
+COPY . .
+
+RUN set -ex; \
+    rm -rf build-q7s; \
+    mkdir build-q7s; \
+    cd build-q7s; \
+    cmake -DCMAKE_BUILD_TYPE=Release -DOS_FSFW=linux -DTGT_BSP="arm/q7s" ..;
+
+ENTRYPOINT ["cmake", "--build", "build-q7s"]
+CMD ["-j"]
+# CMD ["bash"]

bsp_q7s/InitMission.cpp

@@ -0,0 +1,239 @@
+#include "InitMission.h"
+#include "ObjectFactory.h"
+#include "OBSWConfig.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+#include <mission/utility/InitMission.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>
+
+/* This is configured for linux without CR */
+#ifdef LINUX
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+#else
+ServiceInterfaceStream sif::debug("DEBUG", true);
+ServiceInterfaceStream sif::info("INFO", true);
+ServiceInterfaceStream sif::warning("WARNING", true);
+ServiceInterfaceStream sif::error("ERROR", true, false, true);
+#endif
+
+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);
+    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();
+    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);
+    ReturnValue_t result = tmTcDistributor->addComponent(
+            objects::CCSDS_PACKET_DISTRIBUTOR);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
+    }
+    result = tmTcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
+    }
+    result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* udpBridgeTask = factory->createPeriodicTask(
+            "UDP_UNIX_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+    result = udpBridgeTask->addComponent(objects::UDP_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("UDP_BRIDGE", objects::UDP_BRIDGE);
+    }
+    PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
+            "UDP_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+    result = udpPollingTask->addComponent(objects::UDP_POLLING_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("UDP_POLLING", objects::UDP_POLLING_TASK);
+    }
+
+    /* UDP bridge */
+    PeriodicTaskIF* errorReporterTestTask = factory->createPeriodicTask(
+            "ERROR_REPORTER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+    result = udpBridgeTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
+    }
+
+#if TEST_CCSDS_BRIDGE == 1
+    PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
+            "PTME_TEST", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+    result = ptmeTestTask->addComponent(objects::CCSDS_IP_CORE_BRIDGE);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
+    }
+#endif
+
+    /* PUS Services */
+    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) {
+        initmission::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
+    }
+
+    PeriodicTaskIF* pusEvents = factory->createPeriodicTask(
+            "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+    result = pusVerification->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+    }
+
+    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("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+    }
+    result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
+    }
+
+    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("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+    if(result!=HasReturnvaluesIF::RETURN_OK){
+        sif::error << "Object add component failed" << std::endl;
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PUS_200", objects::PUS_SERVICE_200_MODE_MGMT);
+    }
+    result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
+    }
+
+    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("PUS_17", objects::PUS_SERVICE_17_TEST);
+    }
+
+#if TE0720 == 0
+
+    //TODO: Add handling of missed deadlines
+    /* Polling Sequence Table Default */
+#if Q7S_ADD_SPI_TEST == 0
+    FixedTimeslotTaskIF * pollingSequenceTableTaskDefault = factory->createFixedTimeslotTask(
+            "PST_TASK_DEFAULT", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0,
+            missedDeadlineFunc);
+    result = pst::pollingSequenceInitDefault(pollingSequenceTableTaskDefault);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    }
+#endif
+
+    FixedTimeslotTaskIF* gomSpacePstTask = factory->
+            createFixedTimeslotTask("GS_PST_TASK", 50,
+                    PeriodicTaskIF::MINIMUM_STACK_SIZE*8, 1.0, missedDeadlineFunc);
+    result = pst::gomspacePstInit(gomSpacePstTask);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
+    }
+
+#else
+    FixedTimeslotTaskIF * pollingSequenceTaskTE0720 = factory->createFixedTimeslotTask(
+            "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;
+    }
+#endif
+
+#if OBSW_ADD_TEST_CODE == 1
+    PeriodicTaskIF* testTask = factory->createPeriodicTask(
+            "TEST_TASK", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1, missedDeadlineFunc);
+    result = testTask->addComponent(objects::TEST_TASK);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
+    }
+
+#if Q7S_ADD_SPI_TEST == 1
+    result = testTask->addComponent(objects::SPI_TEST);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
+    }
+#endif
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+#if TE0720 == 1 && TEST_LIBGPIOD == 1
+    result = testTask->addComponent(objects::LIBGPIOD_TEST);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
+    }
+#endif /* TE0720 == 1 && TEST_LIBGPIOD == 1 */
+
+    sif::info << "Starting tasks.." << std::endl;
+    tmTcDistributor->startTask();
+    udpBridgeTask->startTask();
+    udpPollingTask->startTask();
+
+#if TE0720 == 0 && Q7S_ADD_SPI_TEST == 0
+    gomSpacePstTask->startTask();
+    pollingSequenceTableTaskDefault->startTask();
+#elif TE0720 == 1 && Q7S_ADD_SPI_TEST == 0
+    pollingSequenceTaskTE0720->startTask();
+#endif
+
+    pusVerification->startTask();
+    pusEvents->startTask();
+    pusHighPrio->startTask();
+    pusMedPrio->startTask();
+    pusLowPrio->startTask();
+
+    errorReporterTestTask->startTask();
+
+#if OBSW_ADD_TEST_CODE == 1
+    testTask->startTask();
+#endif
+
+#if TEST_CCSDS_BRIDGE == 1
+    ptmeTestTask->startTask();
+#endif
+    sif::info << "Tasks started.." << std::endl;
+}

bsp_q7s/InitMission.h

@@ -0,0 +1,9 @@
+#ifndef BSP_Q7S_INITMISSION_H_
+#define BSP_Q7S_INITMISSION_H_
+
+namespace initmission {
+void initMission();
+void initTasks();
+};
+
+#endif /* BSP_Q7S_INITMISSION_H_ */

bsp_q7s/ObjectFactory.cpp

@@ -0,0 +1,633 @@
+#include "ObjectFactory.h"
+#include "OBSWConfig.h"
+#include "tmtc/apid.h"
+#include "devices/addresses.h"
+#include "devices/gpioIds.h"
+#include "tmtc/pusIds.h"
+#include "devices/powerSwitcherList.h"
+#include "spiConf.h"
+
+#include "bsp_q7s/gpio/gpioCallbacks.h"
+#include "bsp_q7s/core/CoreController.h"
+
+#include <linux/devices/HeaterHandler.h>
+#include <linux/devices/SolarArrayDeploymentHandler.h>
+#include <linux/devices/devicedefinitions/SusDefinitions.h>
+#include <linux/devices/SusHandler.h>
+#include <linux/csp/CspCookie.h>
+#include <linux/csp/CspComIF.h>
+
+#include <mission/core/GenericFactory.h>
+#include <mission/devices/PDU1Handler.h>
+#include <mission/devices/PDU2Handler.h>
+#include <mission/devices/ACUHandler.h>
+#include <mission/devices/PCDUHandler.h>
+#include <mission/devices/P60DockHandler.h>
+#include <mission/devices/Tmp1075Handler.h>
+#include <mission/devices/Max31865PT1000Handler.h>
+#include <mission/devices/IMTQHandler.h>
+#include <mission/devices/SyrlinksHkHandler.h>
+#include <mission/devices/MGMHandlerLIS3MDL.h>
+#include <mission/devices/MGMHandlerRM3100.h>
+#include <mission/devices/PlocHandler.h>
+#include <mission/devices/RadiationSensorHandler.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
+#include <mission/devices/devicedefinitions/PlocDefinitions.h>
+#include <mission/devices/devicedefinitions/RadSensorDefinitions.h>
+#include <mission/devices/devicedefinitions/Max31865Definitions.h>
+#include <mission/utility/TmFunnel.h>
+#include <linux/obc/CCSDSIPCoreBridge.h>
+
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
+#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
+#include <fsfw_hal/linux/i2c/I2cCookie.h>
+#include <fsfw_hal/linux/i2c/I2cComIF.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+#include <fsfw/tmtcpacket/pus/tm.h>
+
+/* UDP server includes */
+#include <fsfw/osal/common/UdpTmTcBridge.h>
+#include <fsfw/osal/common/UdpTcPollingTask.h>
+#include <linux/boardtest/SpiTestClass.h>
+
+#if TEST_LIBGPIOD == 1
+#include <linux/boardtest/LibgpiodTest.h>
+#endif
+
+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::UDP_BRIDGE;
+    // No storage object for now.
+    TmFunnel::storageDestination = objects::NO_OBJECT;
+
+    LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
+
+    VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+    TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+
+
+void ObjectFactory::produce(void* args){
+    Factory::setStaticFrameworkObjectIds();
+    ObjectFactory::produceGenericObjects();
+    LinuxLibgpioIF* gpioComIF = new LinuxLibgpioIF(objects::GPIO_IF);
+
+    /* Communication interfaces */
+    new CspComIF(objects::CSP_COM_IF);
+    new I2cComIF(objects::I2C_COM_IF);
+    new UartComIF(objects::UART_COM_IF);
+#if Q7S_ADD_SPI_TEST == 0
+    new SpiComIF(objects::SPI_COM_IF, gpioComIF);
+#endif /* Q7S_ADD_SPI_TEST == 0 */
+
+    new CoreController(objects::CORE_CONTROLLER);
+
+#if TE0720 == 1
+    I2cCookie* i2cCookieTmp1075tcs1 = new I2cCookie(addresses::TMP1075_TCS_1,
+            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
+    I2cCookie* i2cCookieTmp1075tcs2 = new I2cCookie(addresses::TMP1075_TCS_2,
+            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
+#else
+    I2cCookie* i2cCookieTmp1075tcs1 = new I2cCookie(addresses::TMP1075_TCS_1,
+            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-1"));
+    I2cCookie* i2cCookieTmp1075tcs2 = new I2cCookie(addresses::TMP1075_TCS_2,
+            TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-1"));
+#endif
+
+    /* Temperature sensors */
+    Tmp1075Handler* tmp1075Handler_1 = new Tmp1075Handler(
+            objects::TMP1075_HANDLER_1, objects::I2C_COM_IF,
+            i2cCookieTmp1075tcs1);
+    (void) tmp1075Handler_1;
+    Tmp1075Handler* tmp1075Handler_2 = new Tmp1075Handler(
+            objects::TMP1075_HANDLER_2, objects::I2C_COM_IF,
+            i2cCookieTmp1075tcs2);
+    (void) tmp1075Handler_2;
+
+#if TE0720 == 0
+    CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_LENGTH,
+            addresses::P60DOCK);
+    CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH,
+            addresses::PDU1);
+    CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_LENGTH,
+            addresses::PDU2);
+    CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_LENGTH,
+            addresses::ACU);
+    /* Device Handler */
+    P60DockHandler* p60dockhandler = new P60DockHandler(objects::P60DOCK_HANDLER,
+            objects::CSP_COM_IF, p60DockCspCookie);
+    PDU1Handler* pdu1handler = new PDU1Handler(objects::PDU1_HANDLER,
+            objects::CSP_COM_IF, pdu1CspCookie);
+    PDU2Handler* pdu2handler = new PDU2Handler(objects::PDU2_HANDLER,
+            objects::CSP_COM_IF, pdu2CspCookie);
+    ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER,
+            objects::CSP_COM_IF, acuCspCookie);
+    new PCDUHandler(objects::PCDU_HANDLER, 50);
+
+    /**
+     * Setting PCDU devices to mode normal immediately after start up because PCDU is always
+     * running.
+     */
+    /** For now this needs to be commented out because there is no PCDU connected to the OBC */
+//    p60dockhandler->setModeNormal();
+//    pdu1handler->setModeNormal();
+//    pdu2handler->setModeNormal();
+//    acuhandler->setModeNormal();
+    (void) p60dockhandler;
+    (void) pdu1handler;
+    (void) pdu2handler;
+    (void) acuhandler;
+
+    /* Adding gpios for chip select decoding to the gpioComIf */
+    gpioCallbacks::initSpiCsDecoder(gpioComIF);
+
+    GpioCookie* gpioCookieRadSensor = new GpioCookie;
+    GpiodRegular* chipSelectRadSensor = new GpiodRegular(std::string("gpiochip5"), 19,
+            std::string("Chip Select Radiation Sensor"), gpio::OUT, 1);
+    gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
+    gpioComIF->addGpios(gpioCookieRadSensor);
+
+    SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR,
+            std::string("/dev/spidev2.0"), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            spi::DEFAULT_MAX_1227_SPEED);
+    new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
+    GpioCookie* gpioCookieSus = new GpioCookie();
+
+    GpioCallback* susgpio = new GpioCallback(std::string("Chip select SUS 1"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 2"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_2, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 3"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_3, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 4"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_4, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 5"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_5, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 6"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_6, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 7"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_7, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 8"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_8, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 9"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_9, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 10"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_10, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 11"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 12"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_12, susgpio);
+    susgpio = new GpioCallback(std::string("Chip select SUS 13"), gpio::OUT, 1,
+           &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_13, susgpio);
+
+    gpioComIF->addGpios(gpioCookieSus);
+
+    SpiCookie* spiCookieSus1 = new SpiCookie(addresses::SUS_1, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus2 = new SpiCookie(addresses::SUS_2, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus3 = new SpiCookie(addresses::SUS_3, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus4 = new SpiCookie(addresses::SUS_4, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus5 = new SpiCookie(addresses::SUS_5, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus6 = new SpiCookie(addresses::SUS_6, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus7 = new SpiCookie(addresses::SUS_7, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus8 = new SpiCookie(addresses::SUS_8, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus9 = new SpiCookie(addresses::SUS_9, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus10 = new SpiCookie(addresses::SUS_10, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus11 = new SpiCookie(addresses::SUS_11, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus12 = new SpiCookie(addresses::SUS_12, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+    SpiCookie* spiCookieSus13 = new SpiCookie(addresses::SUS_13, gpio::NO_GPIO,
+            std::string("/dev/spidev2.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            SUS::MAX1227_SPI_FREQ);
+
+    new SusHandler(objects::SUS_1, objects::SPI_COM_IF, spiCookieSus1, gpioComIF, gpioIds::CS_SUS_1);
+    new SusHandler(objects::SUS_2, objects::SPI_COM_IF, spiCookieSus2, gpioComIF, gpioIds::CS_SUS_2);
+    new SusHandler(objects::SUS_3, objects::SPI_COM_IF, spiCookieSus3, gpioComIF, gpioIds::CS_SUS_3);
+    new SusHandler(objects::SUS_4, objects::SPI_COM_IF, spiCookieSus4, gpioComIF, gpioIds::CS_SUS_4);
+    new SusHandler(objects::SUS_5, objects::SPI_COM_IF, spiCookieSus5, gpioComIF, gpioIds::CS_SUS_5);
+    new SusHandler(objects::SUS_6, objects::SPI_COM_IF, spiCookieSus6, gpioComIF, gpioIds::CS_SUS_6);
+    new SusHandler(objects::SUS_7, objects::SPI_COM_IF, spiCookieSus7, gpioComIF, gpioIds::CS_SUS_7);
+    new SusHandler(objects::SUS_8, objects::SPI_COM_IF, spiCookieSus8, gpioComIF, gpioIds::CS_SUS_8);
+    new SusHandler(objects::SUS_9, objects::SPI_COM_IF, spiCookieSus9, gpioComIF, gpioIds::CS_SUS_9);
+    new SusHandler(objects::SUS_10, objects::SPI_COM_IF, spiCookieSus10, gpioComIF, gpioIds::CS_SUS_10);
+    new SusHandler(objects::SUS_11, objects::SPI_COM_IF, spiCookieSus11, gpioComIF, gpioIds::CS_SUS_11);
+    new SusHandler(objects::SUS_12, objects::SPI_COM_IF, spiCookieSus12, gpioComIF, gpioIds::CS_SUS_12);
+    new SusHandler(objects::SUS_13, objects::SPI_COM_IF, spiCookieSus13, gpioComIF, gpioIds::CS_SUS_13);
+
+#if OBSW_ADD_ACS_BOARD == 1
+    GpioCookie* gpioCookieAcsBoard = new GpioCookie();
+    GpiodRegular* gpio = nullptr;
+    gpio = new GpiodRegular(std::string("gpiochip5"), 1, std::string("CS_GYRO_0_ADIS"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
+    gpio = new GpiodRegular(std::string("gpiochip5"), 7, std::string("CS_GYRO_1_L3G"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
+    gpio = new GpiodRegular(std::string("gpiochip5"), 3, std::string("CS_GYRO_2_L3G"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_L3G_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 5, std::string("CS_MGM_0_LIS3_A"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 16, std::string("CS_MGM_1_RM3100_A"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip6"), 0, std::string("CS_MGM_2_LIS3_B"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
+
+    gpio = new GpiodRegular(std::string("gpiochip5"), 10, std::string("CS_MGM_3_RM3100_B"),
+            gpio::OUT, gpio::HIGH);
+    gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
+
+    gpioComIF->addGpios(gpioCookieAcsBoard);
+
+    std::string spiDev = "/dev/spidev2.0";
+    SpiCookie* 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 MGMHandlerLIS3MDL(objects::MGM_0_LIS3_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmLis3Handler->setStartUpImmediately();
+
+    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);
+    auto mgmLis3Handler2 = new MGMHandlerLIS3MDL(objects::MGM_2_LIS3_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmLis3Handler2->setStartUpImmediately();
+
+    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 MGMHandlerRM3100(objects::MGM_1_RM3100_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmRm3100Handler->setStartUpImmediately();
+
+    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 MGMHandlerRM3100(objects::MGM_3_RM3100_HANDLER,
+            objects::SPI_COM_IF, spiCookie);
+    mgmRm3100Handler->setStartUpImmediately();
+
+    //TODO: Adis Gyro (Gyro 0 Side A)
+
+    /* Gyro 1 Side A */
+    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);
+    gyroL3gHandler->setStartUpImmediately();
+
+    /* Gyro 2 Side B */
+    spiCookie = new SpiCookie(addresses::GYRO_2_L3G, gpioIds::GYRO_2_L3G_CS, spiDev,
+            L3GD20H::MAX_BUFFER_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+    gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_2_L3G_HANDLER, objects::SPI_COM_IF,
+            spiCookie);
+    gyroL3gHandler->setStartUpImmediately();
+#endif
+
+    GpioCookie* heaterGpiosCookie = new GpioCookie;
+
+    /* Pin H2-11 on stack connector */
+    GpiodRegular* gpioConfigHeater0 = new GpiodRegular(std::string("gpiochip7"), 6,
+            std::string("Heater0"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_0, gpioConfigHeater0);
+
+    /* Pin H2-12 on stack connector */
+    GpiodRegular* gpioConfigHeater1 = new GpiodRegular(std::string("gpiochip7"), 12,
+            std::string("Heater1"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_1, gpioConfigHeater1);
+
+    /* Pin H2-13 on stack connector */
+    GpiodRegular* gpioConfigHeater2 = new GpiodRegular(std::string("gpiochip7"), 7,
+            std::string("Heater2"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_2, gpioConfigHeater2);
+
+    GpiodRegular* gpioConfigHeater3 = new GpiodRegular(std::string("gpiochip7"), 5,
+            std::string("Heater3"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_3, gpioConfigHeater3);
+
+    GpiodRegular* gpioConfigHeater4 = new GpiodRegular(std::string("gpiochip7"), 3,
+            std::string("Heater4"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_4, gpioConfigHeater4);
+
+    GpiodRegular* gpioConfigHeater5 = new GpiodRegular(std::string("gpiochip7"), 0,
+            std::string("Heater5"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_5, gpioConfigHeater5);
+
+    GpiodRegular* gpioConfigHeater6 = new GpiodRegular(std::string("gpiochip7"), 1,
+            std::string("Heater6"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_6, gpioConfigHeater6);
+
+    GpiodRegular* gpioConfigHeater7 = new GpiodRegular(std::string("gpiochip7"), 11,
+            std::string("Heater7"), gpio::OUT, 0);
+    heaterGpiosCookie->addGpio(gpioIds::HEATER_7, gpioConfigHeater7);
+
+    new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, heaterGpiosCookie,
+            objects::PCDU_HANDLER, pcduSwitches::TCS_BOARD_8V_HEATER_IN);
+
+    GpioCookie* solarArrayDeplCookie = new GpioCookie;
+
+    GpiodRegular* gpioConfigDeplSA0 = new GpiodRegular(std::string("gpiochip7"), 4,
+                std::string("DeplSA1"), gpio::OUT, 0);
+    solarArrayDeplCookie->addGpio(gpioIds::DEPLSA1, gpioConfigDeplSA0);
+    GpiodRegular* gpioConfigDeplSA1 = new GpiodRegular(std::string("gpiochip7"), 2,
+                std::string("DeplSA2"), gpio::OUT, 0);
+    solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpioConfigDeplSA1);
+
+    //TODO: Find out burn time. For now set to 1000 ms.
+    new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF,
+            solarArrayDeplCookie, objects::PCDU_HANDLER, pcduSwitches::DEPLOYMENT_MECHANISM,
+            gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000);
+
+    UartCookie* syrlinksUartCookie = new UartCookie(objects::SYRLINKS_HK_HANDLER,
+            std::string("/dev/ttyUL0"), UartModes::NON_CANONICAL, 38400, SYRLINKS::MAX_REPLY_SIZE);
+    syrlinksUartCookie->setParityEven();
+
+    SyrlinksHkHandler* syrlinksHkHandler = new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER,
+            objects::UART_COM_IF, syrlinksUartCookie);
+    syrlinksHkHandler->setModeNormal();
+
+#if Q7S_ADD_RTD_DEVICES == 1
+    GpioCookie* rtdGpioCookie = new GpioCookie;
+
+    GpioCallback* gpioRtdIc3 = new GpioCallback(std::string("Chip select RTD IC3"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC3, gpioRtdIc3);
+    GpioCallback* gpioRtdIc4 = new GpioCallback(std::string("Chip select RTD IC4"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC4, gpioRtdIc4);
+    GpioCallback* gpioRtdIc5 = new GpioCallback(std::string("Chip select RTD IC5"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC5, gpioRtdIc5);
+    GpioCallback* gpioRtdIc6 = new GpioCallback(std::string("Chip select RTD IC6"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC6, gpioRtdIc6);
+    GpioCallback* gpioRtdIc7 = new GpioCallback(std::string("Chip select RTD IC7"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC7, gpioRtdIc7);
+    GpioCallback* gpioRtdIc8 = new GpioCallback(std::string("Chip select RTD IC8"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC8, gpioRtdIc8);
+    GpioCallback* gpioRtdIc9 = new GpioCallback(std::string("Chip select RTD IC9"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC9, gpioRtdIc9);
+    GpioCallback* gpioRtdIc10 = new GpioCallback(std::string("Chip select RTD IC10"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC10, gpioRtdIc10);
+    GpioCallback* gpioRtdIc11 = new GpioCallback(std::string("Chip select RTD IC11"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC11, gpioRtdIc11);
+    GpioCallback* gpioRtdIc12 = new GpioCallback(std::string("Chip select RTD IC12"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC12, gpioRtdIc12);
+    GpioCallback* gpioRtdIc13 = new GpioCallback(std::string("Chip select RTD IC13"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC13, gpioRtdIc13);
+    GpioCallback* gpioRtdIc14 = new GpioCallback(std::string("Chip select RTD IC14"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC14, gpioRtdIc14);
+    GpioCallback* gpioRtdIc15 = new GpioCallback(std::string("Chip select RTD IC15"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC15, gpioRtdIc15);
+    GpioCallback* gpioRtdIc16 = new GpioCallback(std::string("Chip select RTD IC16"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC16, gpioRtdIc16);
+    GpioCallback* gpioRtdIc17 = new GpioCallback(std::string("Chip select RTD IC17"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC17, gpioRtdIc17);
+    GpioCallback* gpioRtdIc18 = new GpioCallback(std::string("Chip select RTD IC18"), gpio::OUT, 1,
+            &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+    rtdGpioCookie->addGpio(gpioIds::RTD_IC18, gpioRtdIc18);
+
+    gpioComIF->addGpios(rtdGpioCookie);
+
+    SpiCookie* spiRtdIc3 = new SpiCookie(addresses::RTD_IC3, gpioIds::RTD_IC3,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_3, 2000000);
+    SpiCookie* spiRtdIc4 = new SpiCookie(addresses::RTD_IC4, gpioIds::RTD_IC4,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc5 = new SpiCookie(addresses::RTD_IC5, gpioIds::RTD_IC5,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc6 = new SpiCookie(addresses::RTD_IC6, gpioIds::RTD_IC6,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc7 = new SpiCookie(addresses::RTD_IC7, gpioIds::RTD_IC7,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc8 = new SpiCookie(addresses::RTD_IC8, gpioIds::RTD_IC8,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc9 = new SpiCookie(addresses::RTD_IC9, gpioIds::RTD_IC9,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc10 = new SpiCookie(addresses::RTD_IC10, gpioIds::RTD_IC10,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc11 = new SpiCookie(addresses::RTD_IC11, gpioIds::RTD_IC11,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc12 = new SpiCookie(addresses::RTD_IC12, gpioIds::RTD_IC12,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc13 = new SpiCookie(addresses::RTD_IC13, gpioIds::RTD_IC13,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc14 = new SpiCookie(addresses::RTD_IC14, gpioIds::RTD_IC14,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc15 = new SpiCookie(addresses::RTD_IC15, gpioIds::RTD_IC15,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 3900000);
+    SpiCookie* spiRtdIc16 = new SpiCookie(addresses::RTD_IC16, gpioIds::RTD_IC16,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc17 = new SpiCookie(addresses::RTD_IC17, gpioIds::RTD_IC17,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+    SpiCookie* spiRtdIc18 = new SpiCookie(addresses::RTD_IC18, gpioIds::RTD_IC18,
+            std::string("/dev/spidev2.0"), Max31865Definitions::MAX_REPLY_SIZE,
+            spi::SpiModes::MODE_1, 2000000);
+
+    Max31865PT1000Handler* rtdIc3 = new Max31865PT1000Handler(objects::RTD_IC3, objects::SPI_COM_IF, spiRtdIc3, 0); // 0 is switchId
+    Max31865PT1000Handler* rtdIc4 = new Max31865PT1000Handler(objects::RTD_IC4, objects::SPI_COM_IF, spiRtdIc4, 0);
+    Max31865PT1000Handler* rtdIc5 = new Max31865PT1000Handler(objects::RTD_IC5, objects::SPI_COM_IF, spiRtdIc5, 0);
+    Max31865PT1000Handler* rtdIc6 = new Max31865PT1000Handler(objects::RTD_IC6, objects::SPI_COM_IF, spiRtdIc6, 0);
+    Max31865PT1000Handler* rtdIc7 = new Max31865PT1000Handler(objects::RTD_IC7, objects::SPI_COM_IF, spiRtdIc7, 0);
+    Max31865PT1000Handler* rtdIc8 = new Max31865PT1000Handler(objects::RTD_IC8, objects::SPI_COM_IF, spiRtdIc8, 0);
+    Max31865PT1000Handler* rtdIc9 = new Max31865PT1000Handler(objects::RTD_IC9, objects::SPI_COM_IF, spiRtdIc9, 0);
+    Max31865PT1000Handler* rtdIc10 = new Max31865PT1000Handler(objects::RTD_IC10, objects::SPI_COM_IF, spiRtdIc10, 0);
+    Max31865PT1000Handler* rtdIc11 = new Max31865PT1000Handler(objects::RTD_IC11, objects::SPI_COM_IF, spiRtdIc11, 0);
+    Max31865PT1000Handler* rtdIc12 = new Max31865PT1000Handler(objects::RTD_IC12, objects::SPI_COM_IF, spiRtdIc12, 0);
+    Max31865PT1000Handler* rtdIc13 = new Max31865PT1000Handler(objects::RTD_IC13, objects::SPI_COM_IF, spiRtdIc13, 0);
+    Max31865PT1000Handler* rtdIc14 = new Max31865PT1000Handler(objects::RTD_IC14, objects::SPI_COM_IF, spiRtdIc14, 0);
+    Max31865PT1000Handler* rtdIc15 = new Max31865PT1000Handler(objects::RTD_IC15, objects::SPI_COM_IF, spiRtdIc15, 0);
+    Max31865PT1000Handler* rtdIc16 = new Max31865PT1000Handler(objects::RTD_IC16, objects::SPI_COM_IF, spiRtdIc16, 0);
+    Max31865PT1000Handler* rtdIc17 = new Max31865PT1000Handler(objects::RTD_IC17, objects::SPI_COM_IF, spiRtdIc17, 0);
+    Max31865PT1000Handler* rtdIc18 = new Max31865PT1000Handler(objects::RTD_IC18, objects::SPI_COM_IF, spiRtdIc18, 0);
+    rtdIc17->setStartUpImmediately();
+//    rtdIc4->setStartUpImmediately();
+
+    (void) rtdIc3;
+    (void) rtdIc4;
+    (void) rtdIc5;
+    (void) rtdIc6;
+    (void) rtdIc7;
+    (void) rtdIc8;
+    (void) rtdIc9;
+    (void) rtdIc10;
+    (void) rtdIc11;
+    (void) rtdIc12;
+    (void) rtdIc13;
+    (void) rtdIc14;
+    (void) rtdIc15;
+    (void) rtdIc16;
+//    (void) rtdIc17;
+    (void) rtdIc18;
+
+#endif /* Q7S_ADD_RTD_DEVICES == 1 */
+
+    I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE,
+            std::string("/dev/i2c-0"));
+    new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
+
+    UartCookie* plocUartCookie = new UartCookie(objects::PLOC_HANDLER, std::string("/dev/ttyUL3"),
+            UartModes::NON_CANONICAL, 115200, PLOC::MAX_REPLY_SIZE);
+    PlocHandler* plocHandler = new PlocHandler(objects::PLOC_HANDLER, objects::UART_COM_IF,
+            plocUartCookie);
+//    plocHandler->setStartUpImmediately();
+    (void) plocHandler;
+
+#endif /* TE0720 == 0 */
+
+    new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
+    new UdpTcPollingTask(objects::UDP_POLLING_TASK, objects::UDP_BRIDGE);
+
+#if TE0720 == 1 && TEST_LIBGPIOD == 1
+    /* Configure MIO0 as input */
+    GpiodRegular gpioConfigMio0(std::string("gpiochip0"), 0,
+            std::string("MIO0"), gpio::IN, 0);
+    GpioCookie* gpioCookie = new GpioCookie;
+    gpioCookie->addGpio(gpioIds::TEST_ID_0, gpioConfigMio0);
+    new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
+#endif
+
+#if TE0720 == 1 && TEST_SUS_HANDLER == 1
+    GpioCookie* gpioCookieSus = new GpioCookie;
+    GpiodRegular* chipSelectSus = new GpiodRegular(std::string("gpiochip1"), 9,
+            std::string("Chip Select Sus Sensor"), gpio::OUT, 1);
+    gpioCookieSus->addGpio(gpioIds::CS_SUS_1, chipSelectSus);
+    gpioComIF->addGpios(gpioCookieSus);
+
+    SpiCookie* spiCookieSus = new SpiCookie(addresses::SUS_1, std::string("/dev/spidev1.0"),
+            SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
+
+    new SusHandler(objects::SUS_1, objects::SPI_COM_IF, spiCookieSus, gpioComIF,
+            gpioIds::CS_SUS_1);
+#endif
+
+#if TE0720 == 1 && TEST_CCSDS_BRIDGE == 1
+    GpioCookie* gpioCookieCcsdsIp = new GpioCookie;
+    GpiodRegular* papbBusyN = new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_N"));
+    gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN);
+    GpiodRegular* papbEmpty = new GpiodRegular(std::string("gpiochip0"), 1,
+            std::string("Chip Select Sus Sensor"));
+    gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty);
+    gpioComIF->addGpios(gpioCookieCcsdsIp);
+
+    new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR,
+            objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"),
+            gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
+#endif
+
+#if TE0720 == 1 && TEST_RADIATION_SENSOR_HANDLER == 1
+    GpioCookie* gpioCookieRadSensor = new GpioCookie;
+    GpiodRegular* chipSelectRadSensor = new GpiodRegular(std::string("gpiochip1"), 0,
+            std::string("Chip select radiation sensor"), gpio::OUT, 1);
+    gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
+    gpioComIF->addGpios(gpioCookieRadSensor);
+
+    SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR,
+            std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE,
+            spi::DEFAULT_MAX_1227_SPEED);
+
+    RadiationSensorHandler* radSensor = new RadiationSensorHandler(objects::RAD_SENSOR,
+            objects::SPI_COM_IF, spiCookieRadSensor);
+    radSensor->setStartUpImmediately();
+#endif
+
+#if TE0720 == 1 && TEST_PLOC_HANDLER == 1
+    UartCookie* plocUartCookie = new UartCookie(std::string("/dev/ttyPS1"), 115200,
+            PLOC::MAX_REPLY_SIZE);
+    /* Testing PlocHandler on TE0720-03-1CFA */
+    PlocHandler* plocHandler = new PlocHandler(objects::PLOC_HANDLER, objects::UART_COM_IF,
+            plocUartCookie);
+    plocHandler->setStartUpImmediately();
+#endif
+
+#if TE0720 == 1 && TE0720_HEATER_TEST == 1
+    /* Configuration for MIO0 on TE0720-03-1CFA */
+    GpiodRegular* heaterGpio = new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0);
+    GpioCookie* gpioCookie = new GpioCookie;
+    gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio);
+    new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER,
+            pcduSwitches::TCS_BOARD_8V_HEATER_IN);
+#endif
+
+#if Q7S_ADD_SPI_TEST == 1
+    new SpiTestClass(objects::SPI_TEST, gpioComIF);
+#endif
+}

bsp_q7s/ObjectFactory.h

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

bsp_q7s/boardconfig/CMakeLists.txt

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

bsp_q7s/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_q7s/boardconfig/gcov.h

@@ -0,0 +1,14 @@
+#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_q7s/boardconfig/print.c

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

bsp_q7s/boardconfig/q7sConfig.h.in

@@ -0,0 +1,13 @@
+#ifndef BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_
+#define BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_
+
+#define Q7S_ADD_RTD_DEVICES 			0
+
+/* Only one of those 2 should be enabled! */
+/* Add code for ACS board */
+#define OBSW_ADD_ACS_BOARD              0
+#define Q7S_ADD_SPI_TEST                0
+
+
+
+#endif /* BSP_Q7S_BOARDCONFIG_Q7S_CONFIG_H_ */

bsp_q7s/boardtest/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE
+)
+
+
+
+

bsp_q7s/bsp_q7s.mk

@@ -0,0 +1,6 @@
+CXXSRC += $(wildcard $(CURRENTPATH)/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/comIF/cookies/*.cpp)
+CXXSRC += $(wildcard $(CURRENTPATH)/comIF/*.cpp)
+CSRC += $(wildcard $(CURRENTPATH)/*.c)
+
+CSRC += $(wildcard $(CURRENTPATH)/boardconfig/*.c)

bsp_q7s/comIF/CMakeLists.txt

@@ -0,0 +1,6 @@
+target_sources(${TARGET_NAME} PRIVATE
+)
+
+
+
+

bsp_q7s/core/CMakeLists.txt

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

bsp_q7s/core/CoreController.cpp

@@ -0,0 +1,26 @@
+#include "CoreController.h"
+
+CoreController::CoreController(object_id_t objectId):
+        ExtendedControllerBase(objectId, objects::NO_OBJECT, 5) {
+}
+
+ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void CoreController::performControlOperation() {
+}
+
+ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+        LocalDataPoolManager &poolManager) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolDataSetBase* CoreController::getDataSetHandle(sid_t sid) {
+    return nullptr;
+}
+
+ReturnValue_t CoreController::checkModeCommand(Mode_t mode, Submode_t submode,
+        uint32_t *msToReachTheMode) {
+    return HasReturnvaluesIF::RETURN_OK;
+}

bsp_q7s/core/CoreController.h

@@ -0,0 +1,22 @@
+#ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
+#define BSP_Q7S_CORE_CORECONTROLLER_H_
+
+#include "fsfw/controller/ExtendedControllerBase.h"
+
+class CoreController: public ExtendedControllerBase {
+public:
+    CoreController(object_id_t objectId);
+
+    ReturnValue_t handleCommandMessage(CommandMessage *message) override;
+    void performControlOperation() override;
+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);
+};
+
+
+
+#endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */

bsp_q7s/gpio/CMakeLists.txt

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

bsp_q7s/gpio/gpioCallbacks.cpp

@@ -0,0 +1,308 @@
+#include "gpioCallbacks.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;
+
+    /** Setting mux bit 1 to low will disable IC21 on the interface board */
+    GpiodRegular* spiMuxBit1 = new GpiodRegular(std::string("gpiochip7"), 13,
+            std::string("SPI Mux Bit 1"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit1);
+    /** Setting mux bit 2 to low disables IC1 on the TCS board */
+    GpiodRegular* spiMuxBit2 = new GpiodRegular(std::string("gpiochip7"), 14,
+            std::string("SPI Mux Bit 2"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit2);
+    /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
+    GpiodRegular* spiMuxBit3 = new GpiodRegular(std::string("gpiochip7"), 15,
+            std::string("SPI Mux Bit 3"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit3);
+    /** The following gpios can take arbitrary initial values */
+    GpiodRegular* spiMuxBit4 = new GpiodRegular(std::string("gpiochip7"), 16,
+            std::string("SPI Mux Bit 4"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit4);
+    GpiodRegular* spiMuxBit5 = new GpiodRegular(std::string("gpiochip7"), 17,
+            std::string("SPI Mux Bit 5"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit5);
+    GpiodRegular* spiMuxBit6 = new GpiodRegular(std::string("gpiochip7"), 18,
+            std::string("SPI Mux Bit 6"), gpio::OUT, 0);
+    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_6, spiMuxBit6);
+
+    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;
+        }
+        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 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);
+}
+
+}

bsp_q7s/gpio/gpioCallbacks.h

@@ -0,0 +1,62 @@
+#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   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

@@ -1,7 +1,7 @@
 #include "InitMission.h"
-
 #include <OBSWVersion.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include "OBSWConfig.h"
 
 #include <iostream>
 
@@ -14,15 +14,19 @@
 int main(void)
 {
     std::cout << "-- EIVE OBSW --" << std::endl;
-    std::cout << "-- Compiled for Linux " << " --" << std::endl;
+#if TE0720 == 0
+    std::cout << "-- Compiled for Linux (Xiphos Q7S) --" << std::endl;
+#else
+    std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;
+#endif
     std::cout << "-- Software version " << SW_NAME << " v" << SW_VERSION << "."
     		<< SW_SUBVERSION << "." << SW_SUBSUBVERSION << " -- " << std::endl;
     std::cout << "-- " <<  __DATE__ << " " << __TIME__ << " --" << std::endl;
 
-	InitMission::initMission();
+	initmission::initMission();
 
 	for(;;) {
-		// suspend main thread by sleeping it.
+		/* Suspend main thread by sleeping it. */
 		TaskFactory::delayTask(5000);
 	}
 }

bsp_q7s/memory/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${TARGET_NAME} PRIVATE
+    FileSystemManager.cpp
+    SdCardAccess.cpp
+)

bsp_q7s/memory/FileSystemManager.cpp

@@ -0,0 +1,7 @@
+#include "FileSystemManager.h"
+
+class FileSystemManager {
+public:
+
+private:
+};

bsp_q7s/memory/FileSystemManager.h

@@ -0,0 +1,8 @@
+#ifndef BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_
+#define BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_
+
+
+
+
+
+#endif /* BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_ */

bsp_q7s/memory/SdCardAccess.cpp

@@ -0,0 +1,4 @@
+#include "SdCardAccess.h"
+
+SdCardAccess::SdCardAccess() {
+}

bsp_q7s/memory/SdCardAccess.h

@@ -0,0 +1,11 @@
+#ifndef BSP_Q7S_MEMORY_SDCARDACCESS_H_
+#define BSP_Q7S_MEMORY_SDCARDACCESS_H_
+
+class SdCardAccess {
+public:
+    SdCardAccess();
+private:
+};
+
+
+#endif /* BSP_Q7S_MEMORY_SDCARDACCESS_H_ */

cmake/BBBCrossCompileConfig.cmake

@@ -0,0 +1,98 @@
+# BBB_ROOTFS should point to the local directory which contains all the 
+# libraries and includes from the target raspi.
+# The following command can be used to do this, replace <ip-address> and the
+# local <rootfs-path> accordingly:
+# rsync -vR --progress -rl --delete-after --safe-links pi@<ip-address>:/{lib,usr,opt/vc/lib} <rootfs-path>
+# RASPBIAN_ROOTFS needs to be passed to the CMake command or defined in the
+# application CMakeLists.txt before loading the toolchain file.
+
+# CROSS_COMPILE also needs to be set accordingly or passed to the CMake command
+
+if(NOT DEFINED ENV{BBB_ROOTFS})
+	message(FATAL_ERROR 
+		"Define the BBB_ROOTFS variable to point to the Beagle Bone Black rootfs."
+	)
+else()
+	set(SYSROOT_PATH "$ENV{BBB_ROOTFS}" CACHE  FILEPATH "BBB root filesystem path")
+	message(STATUS "Beagle Bone Black sysroot: ${SYSROOT_PATH}")
+endif()
+
+if(NOT DEFINED ENV{CROSS_COMPILE})
+	set(CROSS_COMPILE "arm-linux-gnueabihf")
+	message(STATUS 
+		"No CROSS_COMPILE environmental variable set, using default ARM linux "
+		"cross compiler name ${CROSS_COMPILE}"
+	)
+else()
+	set(CROSS_COMPILE "$ENV{CROSS_COMPILE}")
+	message(STATUS 
+		"Using environmental variable CROSS_COMPILE as cross-compiler: "
+		"$ENV{CROSS_COMPILE}"
+	)
+endif()
+
+message(STATUS "Using sysroot path: ${SYSROOT_PATH}")
+
+set(CROSS_COMPILE_CC "${CROSS_COMPILE}-gcc")
+set(CROSS_COMPILE_CXX "${CROSS_COMPILE}-g++")
+set(CROSS_COMPILE_LD "${CROSS_COMPILE}-ld")
+set(CROSS_COMPILE_AR "${CROSS_COMPILE}-ar")
+set(CROSS_COMPILE_RANLIB "${CROSS_COMPILE}-ranlib")
+set(CROSS_COMPILE_STRIP "${CROSS_COMPILE}-strip")
+set(CROSS_COMPILE_NM "${CROSS_COMPILE}-nm")
+set(CROSS_COMPILE_OBJCOPY "${CROSS_COMPILE}-objcopy")
+set(CROSS_COMPILE_SIZE "${CROSS_COMPILE}-size")
+
+# At the very least, cross compile gcc and g++ have to be set!
+find_program (CROSS_COMPILE_CC_FOUND ${CROSS_COMPILE_CC} REQUIRED)
+find_program (CROSS_COMPILE_CXX_FOUND ${CROSS_COMPILE_CXX} REQUIRED)
+
+set(CMAKE_CROSSCOMPILING TRUE)
+set(CMAKE_SYSROOT "${SYSROOT_PATH}")
+
+# Define name of the target system
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_PROCESSOR "arm")
+
+# Define the compiler
+set(CMAKE_C_COMPILER ${CROSS_COMPILE_CC})
+set(CMAKE_CXX_COMPILER ${CROSS_COMPILE_CXX})
+
+# List of library dirs where LD has to look. Pass them directly through gcc. 
+# LD_LIBRARY_PATH is not evaluated by arm-*-ld
+set(LIB_DIRS 
+	"${SYSROOT_PATH}/lib/${CROSS_COMPILE}"
+	"${SYSROOT_PATH}/usr/local/lib"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
+	"${SYSROOT_PATH}/usr/lib"
+)
+# You can additionally check the linker paths if you add the 
+# flags ' -Xlinker --verbose'
+set(COMMON_FLAGS "-I${SYSROOT_PATH}/usr/include")
+foreach(LIB ${LIB_DIRS})
+	set(COMMON_FLAGS "${COMMON_FLAGS} -L${LIB} -Wl,-rpath-link,${LIB}")
+endforeach()
+
+set(CMAKE_PREFIX_PATH 
+	"${CMAKE_PREFIX_PATH}"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
+)
+
+set(CMAKE_C_FLAGS 
+	"-march=armv7-a -mtune=cortex-a8 -mfpu=neon -mfloat-abi=hard ${COMMON_FLAGS}" 
+	CACHE STRING "Flags for Beagle Bone Black"
+)
+set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" 
+	CACHE STRING "Flags for Beagle Bone Black"
+)
+
+set(CMAKE_FIND_ROOT_PATH 
+	"${CMAKE_INSTALL_PREFIX};${CMAKE_PREFIX_PATH};${CMAKE_SYSROOT}"
+)
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

cmake/BuildType.cmake

@@ -0,0 +1,45 @@
+function(set_build_type)
+
+message(STATUS "Used build generator: ${CMAKE_GENERATOR}")
+
+# Set a default build type if none was specified
+set(DEFAULT_BUILD_TYPE "RelWithDebInfo")
+if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
+	set(DEFAULT_BUILD_TYPE "Debug")
+endif()
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+	message(STATUS 
+		"Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified."
+	)
+	set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE
+		STRING "Choose the type of build." FORCE
+	)
+	# Set the possible values of build type for cmake-gui
+	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+		"Debug" "Release" "MinSizeRel" "RelWithDebInfo"
+	)
+endif()
+
+if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
+	message(STATUS 
+		"Building Debug application with flags: ${CMAKE_C_FLAGS_DEBUG}"
+	)
+elseif(${CMAKE_BUILD_TYPE} MATCHES "RelWithDebInfo")
+	message(STATUS 
+		"Building Release (Debug) application with "
+		"flags: ${CMAKE_C_FLAGS_RELWITHDEBINFO}"
+	)
+elseif(${CMAKE_BUILD_TYPE} MATCHES "MinSizeRel")
+	message(STATUS 
+		"Building Release (Size) application with "
+		"flags: ${CMAKE_C_FLAGS_MINSIZEREL}"
+	)
+else()
+	message(STATUS 
+		"Building Release (Speed) application with "
+		"flags: ${CMAKE_C_FLAGS_RELEASE}"
+	)
+endif()
+
+endfunction()

cmake/HardwareOsPostConfig.cmake

@@ -0,0 +1,62 @@
+function(post_source_hw_os_config)
+
+if(LINK_LWIP)
+	message(STATUS "Linking against ${LIB_LWIP_NAME} lwIP library")
+	if(LIB_LWIP_NAME)
+		target_link_libraries(${TARGET_NAME} PUBLIC 
+			${LIB_LWIP_NAME}
+		)
+	else()
+		message(WARNING "lwIP library name not set!")
+	endif()
+endif()
+
+if(LINK_HAL)
+	message(STATUS "Linking against ${LIB_HAL_NAME} HAL library")
+	if(LIB_HAL_NAME)
+		target_link_libraries(${TARGET_NAME} PUBLIC
+			${LIB_HAL_NAME}
+		)
+	else()
+		message(WARNING "HAL library name not set!")
+	endif()
+endif()
+
+if(LINKER_SCRIPT)
+	target_link_options(${TARGET_NAME} PRIVATE
+		-T${LINKER_SCRIPT}
+	)
+endif()
+	
+set(C_FLAGS "" CACHE INTERNAL "C flags")
+
+set(C_DEFS ""
+	CACHE INTERNAL
+	"C Defines"
+)
+
+set(CXX_FLAGS ${C_FLAGS})
+set(CXX_DEFS ${C_DEFS})
+
+if(CMAKE_VERBOSE)
+	message(STATUS "C Flags: ${C_FLAGS}")
+	message(STATUS "CXX Flags: ${CXX_FLAGS}")
+	message(STATUS "C Defs: ${C_DEFS}")
+	message(STATUS "CXX Defs: ${CXX_DEFS}")
+endif()
+
+# Generator expression. Can be used to set different C, CXX and ASM flags.
+target_compile_options(${TARGET_NAME} PRIVATE
+	$<$<COMPILE_LANGUAGE:C>:${C_DEFS} ${C_FLAGS}>
+	$<$<COMPILE_LANGUAGE:CXX>:${CXX_DEFS} ${CXX_FLAGS}>
+	$<$<COMPILE_LANGUAGE:ASM>:${ASM_FLAGS}>
+)
+
+add_custom_command(
+	TARGET ${TARGET_NAME}
+	POST_BUILD
+	COMMAND ${CMAKE_OBJCOPY} -O binary ${TARGET_NAME} ${TARGET_NAME}.bin
+	COMMENT "Generating binary file ${CMAKE_PROJECT_NAME}.bin.."
+)
+
+endfunction()

cmake/HardwareOsPreConfig.cmake

@@ -0,0 +1,70 @@
+function(pre_source_hw_os_config)
+
+# FreeRTOS
+if(${OS_FSFW} MATCHES freertos)
+	message(FATAL_ERROR "No FreeRTOS support implemented yet.")
+# RTEMS
+elseif(${OS_FSFW} STREQUAL rtems)
+	add_definitions(-DRTEMS)
+	message(FATAL_ERROR "No RTEMS support implemented yet.")
+elseif(${OS_FSFW} STREQUAL linux)
+	add_definitions(-DUNIX -DLINUX)	
+	find_package(Threads REQUIRED)
+# Hosted
+else()
+	set(BSP_PATH "bsp_hosted")
+	if(WIN32)
+    	add_definitions(-DWIN32)
+	elseif(UNIX)
+		find_package(Threads REQUIRED)
+		add_definitions(-DUNIX -DLINUX)	
+	endif()
+endif()
+
+# Cross-compile information
+if(CMAKE_CROSSCOMPILING)
+	# set(CMAKE_VERBOSE TRUE)
+
+	message(STATUS "Cross-compiling for ${TGT_BSP} target")
+	message(STATUS "Cross-compile gcc: ${CMAKE_C_COMPILER}")
+	message(STATUS "Cross-compile g++: ${CMAKE_CXX_COMPILER}")
+	
+	if(CMAKE_VERBOSE)
+		message(STATUS "Cross-compile linker: ${CMAKE_LINKER}")
+		message(STATUS "Cross-compile size utility: ${CMAKE_SIZE}")
+		message(STATUS "Cross-compile objcopy utility: ${CMAKE_OBJCOPY}")
+		message(STATUS "Cross-compile ranlib utility: ${CMAKE_RANLIB}")
+		message(STATUS "Cross-compile ar utility: ${CMAKE_AR}")
+		message(STATUS "Cross-compile nm utility: ${CMAKE_NM}")
+		message(STATUS "Cross-compile strip utility: ${CMAKE_STRIP}")
+		message(STATUS 
+			"Cross-compile assembler: ${CMAKE_ASM_COMPILER} "
+			"-x assembler-with-cpp"
+		)
+		message(STATUS "ABI flags: ${ABI_FLAGS}")
+		message(STATUS "Custom linker script: ${LINKER_SCRIPT}")
+	endif()
+	
+	set_property(CACHE TGT_BSP 
+		PROPERTY STRINGS  
+		"arm/q7s" "arm/raspberrypi" 
+	)
+endif()
+	
+
+if(TGT_BSP)
+	if (${TGT_BSP} MATCHES "arm/raspberrypi" OR ${TGT_BSP} MATCHES "arm/beagleboneblack")
+		set(BSP_PATH "bsp_linux_board")
+	elseif(${TGT_BSP} MATCHES "arm/q7s")
+		set(BSP_PATH "bsp_q7s")
+	else() 
+		message(WARNING "CMake not configured for this target!")
+		message(FATAL_ERROR "Target: ${TGT_BSP}!")
+	endif()
+else()
+	set(BSP_PATH "bsp_hosted")
+endif()
+		
+set(BSP_PATH ${BSP_PATH} PARENT_SCOPE)
+
+endfunction()

cmake/PreProjectConfig.cmake

@@ -0,0 +1,65 @@
+function(pre_project_config)
+
+# Basic input sanitization
+if(DEFINED TGT_BSP)
+	if(${TGT_BSP} MATCHES "arm/raspberrypi" AND NOT ${OS_FSFW} MATCHES linux)
+		message(STATUS "FSFW OSAL invalid for specified target BSP ${TGT_BSP}!")
+		message(STATUS "Setting valid OS_FSFW: linux") 
+		set(OS_FSFW "linux")
+	endif()
+endif()
+
+# Disable compiler checks for cross-compiling.
+if(${OS_FSFW} STREQUAL linux AND TGT_BSP)
+	if(${TGT_BSP} MATCHES "arm/q7s")
+		set(CMAKE_TOOLCHAIN_FILE 
+			"${CMAKE_SCRIPT_PATH}/Q7SCrossCompileConfig.cmake"
+			PARENT_SCOPE
+		)
+	elseif (${TGT_BSP} MATCHES "arm/raspberrypi")
+		if(NOT DEFINED ENV{RASPBIAN_ROOTFS})
+			if(NOT DEFINED RASPBIAN_ROOTFS)
+			    message(WARNING "No RASPBIAN_ROOTFS environmental or CMake variable set!")
+				set(ENV{RASPBIAN_ROOTFS} "$ENV{HOME}/raspberrypi/rootfs")
+			else()
+				set(ENV{RASPBIAN_ROOTFS} "${RASPBIAN_ROOTFS}")
+			endif()
+		else()	
+			message(STATUS 
+			    "RASPBIAN_ROOTFS from environmental variables used: $ENV{RASPBIAN_ROOTFS}"
+			)
+		endif()
+	
+		if(NOT DEFINED ENV{RASPBERRY_VERSION})
+			if(NOT RASPBERRY_VERSION)
+				message(STATUS "No RASPBERRY_VERSION specified, setting to 4")
+				set(RASPBERRY_VERSION "4" CACHE STRING "Raspberry Pi version")
+			else()
+				message(STATUS "Setting RASPBERRY_VERSION to ${RASPBERRY_VERSION}")
+				set(RASPBERRY_VERSION ${RASPBERRY_VERSION} CACHE STRING "Raspberry Pi version")
+		        set(ENV{RASPBERRY_VERSION} ${RASPBERRY_VERSION})
+			endif()
+		else()
+			message(STATUS 
+				"RASPBERRY_VERSION from environmental variables used: "
+				"$ENV{RASPBERRY_VERSION}"
+			)
+		endif()
+
+		set(CMAKE_TOOLCHAIN_FILE 
+			"${CMAKE_SCRIPT_PATH}/RPiCrossCompileConfig.cmake"
+			PARENT_SCOPE
+		)
+    elseif(${TGT_BSP} MATCHES "arm/beagleboneblack")
+        if(LINUX_CROSS_COMPILE)
+            set(CMAKE_TOOLCHAIN_FILE
+                "${CMAKE_SCRIPT_PATH}/BBBCrossCompileConfig.cmake"
+                PARENT_SCOPE
+            )
+        endif()
+    else()
+		message(WARNING "Target BSP (TGT_BSP) ${TGT_BSP} unknown!")
+	endif()
+endif()
+
+endfunction()

cmake/Q7SCrossCompileConfig.cmake

@@ -0,0 +1,88 @@
+# CROSS_COMPILE also needs to be set accordingly or passed to the CMake command
+
+if(NOT DEFINED ENV{Q7S_SYSROOT})
+#	message(FATAL_ERROR 
+#		"Define the Q7S_ROOTFS variable to "
+#		"point to the raspbian rootfs."
+#	)
+else()
+	set(SYSROOT_PATH "$ENV{Q7S_SYSROOT}" CACHE PATH "Q7S root filesystem path")
+endif()
+
+if(NOT DEFINED ENV{CROSS_COMPILE})
+	set(CROSS_COMPILE "arm-linux-gnueabihf")
+	message(STATUS 
+		"No CROSS_COMPILE environmental variable set, using default ARM linux "
+		"cross compiler name ${CROSS_COMPILE}"
+	)
+else()
+	set(CROSS_COMPILE "$ENV{CROSS_COMPILE}")
+	message(STATUS 
+		"Using environmental variable CROSS_COMPILE as cross-compiler: "
+		"$ENV{CROSS_COMPILE}"
+	)
+endif()
+
+message(STATUS "Using sysroot path: ${SYSROOT_PATH}")
+
+set(CROSS_COMPILE_CC "${CROSS_COMPILE}-gcc")
+set(CROSS_COMPILE_CXX "${CROSS_COMPILE}-g++")
+set(CROSS_COMPILE_LD "${CROSS_COMPILE}-ld")
+set(CROSS_COMPILE_AR "${CROSS_COMPILE}-ar")
+set(CROSS_COMPILE_RANLIB "${CROSS_COMPILE}-ranlib")
+set(CROSS_COMPILE_STRIP "${CROSS_COMPILE}-strip")
+set(CROSS_COMPILE_NM "${CROSS_COMPILE}-nm")
+set(CROSS_COMPILE_OBJCOPY "${CROSS_COMPILE}-objcopy")
+set(CROSS_COMPILE_SIZE "${CROSS_COMPILE}-size")
+
+# At the very least, cross compile gcc and g++ have to be set!
+find_program (CROSS_COMPILE_CC_FOUND ${CROSS_COMPILE_CC} REQUIRED)
+find_program (CROSS_COMPILE_CXX_FOUND ${CROSS_COMPILE_CXX} REQUIRED)
+
+set(CMAKE_CROSSCOMPILING TRUE)
+set(CMAKE_SYSROOT "${SYSROOT_PATH}")
+
+# Define name of the target system
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+
+# Define the compiler
+set(CMAKE_C_COMPILER ${CROSS_COMPILE_CC})
+set(CMAKE_CXX_COMPILER ${CROSS_COMPILE_CXX})
+
+# List of library dirs where LD has to look. Pass them directly through gcc. 
+set(LIB_DIRS 
+	"${SYSROOT_PATH}/usr/include"
+	"${SYSROOT_PATH}/usr/include/linux"
+	"${SYSROOT_PATH}/usr/lib"
+	"${SYSROOT_PATH}/lib"
+	"${SYSROOT_PATH}"
+	"${SYSROOT_PATH}/usr/lib/arm-xiphos-linux-gnueabi"
+)
+# You can additionally check the linker paths if you add the 
+# flags ' -Xlinker --verbose'
+set(COMMON_FLAGS "-I${SYSROOT_PATH}/usr/lib")
+foreach(LIB ${LIB_DIRS})
+	set(COMMON_FLAGS "${COMMON_FLAGS} -L${LIB} -Wl,-rpath-link,${LIB}")
+endforeach()
+
+set(CMAKE_PREFIX_PATH 
+	"${CMAKE_PREFIX_PATH}"
+	# "${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
+)
+
+set(CMAKE_C_FLAGS 
+	"-mcpu=cortex-a9 -mfpu=neon-vfpv3 -mfloat-abi=hard ${COMMON_FLAGS} -lgpiod" 
+	CACHE STRING "C flags for Q7S"
+)
+set(CMAKE_CXX_FLAGS 
+	"${CMAKE_C_FLAGS}" 
+	CACHE STRING "CPP flags for Q7S"
+)
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

cmake/RPiCrossCompileConfig.cmake

@@ -0,0 +1,146 @@
+# Based on https://github.com/Pro/raspi-toolchain but rewritten completely.
+
+# Adapted for the FSFW Example
+if(NOT $ENV{RASPBERRY_VERSION})
+	message(STATUS "Raspberry Pi version not specified, setting version 4!")
+	set(RASPBERRY_VERSION 4)
+else()
+	set(RASPBERRY_VERSION $ENV{RASPBERRY_VERSION})
+endif()
+
+
+# RASPBIAN_ROOTFS should point to the local directory which contains all the 
+# libraries and includes from the target raspi.
+# The following command can be used to do this, replace <ip-address> and the
+# local <rootfs-path> accordingly:
+# rsync -vR --progress -rl --delete-after --safe-links pi@<ip-address>:/{lib,usr,opt/vc/lib} <rootfs-path>
+# RASPBIAN_ROOTFS needs to be passed to the CMake command or defined in the
+# application CMakeLists.txt before loading the toolchain file.
+
+# CROSS_COMPILE also needs to be set accordingly or passed to the CMake command
+
+if(NOT DEFINED ENV{RASPBIAN_ROOTFS})
+	message(FATAL_ERROR 
+		"Define the RASPBIAN_ROOTFS variable to "
+		"point to the raspbian rootfs."
+	)
+else()
+	set(SYSROOT_PATH "$ENV{RASPBIAN_ROOTFS}" CACHE FILEPATH "RPi root filesystem path")
+endif()
+
+if(NOT DEFINED ENV{CROSS_COMPILE})
+	set(CROSS_COMPILE "arm-linux-gnueabihf")
+	message(STATUS 
+		"No CROSS_COMPILE environmental variable set, using default ARM linux "
+		"cross compiler name ${CROSS_COMPILE}"
+	)
+else()
+	set(CROSS_COMPILE "$ENV{CROSS_COMPILE}")
+	message(STATUS 
+		"Using environmental variable CROSS_COMPILE as cross-compiler: "
+		"$ENV{CROSS_COMPILE}"
+	)
+endif()
+
+message(STATUS "Using sysroot path: ${SYSROOT_PATH}")
+
+set(CROSS_COMPILE_CC "${CROSS_COMPILE}-gcc")
+set(CROSS_COMPILE_CXX "${CROSS_COMPILE}-g++")
+set(CROSS_COMPILE_LD "${CROSS_COMPILE}-ld")
+set(CROSS_COMPILE_AR "${CROSS_COMPILE}-ar")
+set(CROSS_COMPILE_RANLIB "${CROSS_COMPILE}-ranlib")
+set(CROSS_COMPILE_STRIP "${CROSS_COMPILE}-strip")
+set(CROSS_COMPILE_NM "${CROSS_COMPILE}-nm")
+set(CROSS_COMPILE_OBJCOPY "${CROSS_COMPILE}-objcopy")
+set(CROSS_COMPILE_SIZE "${CROSS_COMPILE}-size")
+
+# At the very least, cross compile gcc and g++ have to be set!
+find_program (CROSS_COMPILE_CC_FOUND ${CROSS_COMPILE_CC} REQUIRED)
+find_program (CROSS_COMPILE_CXX_FOUND ${CROSS_COMPILE_CXX} REQUIRED)
+
+set(CMAKE_CROSSCOMPILING TRUE)
+set(CMAKE_SYSROOT "${SYSROOT_PATH}")
+
+# Define name of the target system
+set(CMAKE_SYSTEM_NAME "Linux")
+if(RASPBERRY_VERSION VERSION_GREATER 1)
+	set(CMAKE_SYSTEM_PROCESSOR "armv7")
+else()
+	set(CMAKE_SYSTEM_PROCESSOR "arm")
+endif()
+
+# Define the compiler
+set(CMAKE_C_COMPILER ${CROSS_COMPILE_CC})
+set(CMAKE_CXX_COMPILER ${CROSS_COMPILE_CXX})
+
+# List of library dirs where LD has to look. Pass them directly through gcc. 
+# LD_LIBRARY_PATH is not evaluated by arm-*-ld
+set(LIB_DIRS 
+	"/opt/cross-pi-gcc/arm-linux-gnueabihf/lib"
+	"/opt/cross-pi-gcc/lib"
+	"${SYSROOT_PATH}/opt/vc/lib"
+	"${SYSROOT_PATH}/lib/${CROSS_COMPILE}"
+	"${SYSROOT_PATH}/usr/local/lib"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
+	"${SYSROOT_PATH}/usr/lib"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}/blas"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}/lapack"
+)
+# You can additionally check the linker paths if you add the 
+# flags ' -Xlinker --verbose'
+set(COMMON_FLAGS "-I${SYSROOT_PATH}/usr/include")
+foreach(LIB ${LIB_DIRS})
+	set(COMMON_FLAGS "${COMMON_FLAGS} -L${LIB} -Wl,-rpath-link,${LIB}")
+endforeach()
+
+set(CMAKE_PREFIX_PATH 
+	"${CMAKE_PREFIX_PATH}"
+	"${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
+)
+
+if(RASPBERRY_VERSION VERSION_GREATER 3)
+	set(CMAKE_C_FLAGS 
+		"-mcpu=cortex-a72 -mfpu=neon-vfpv4 -mfloat-abi=hard ${COMMON_FLAGS}" 
+		CACHE STRING "CPP flags for Raspberry PI 4"
+	)
+	set(CMAKE_CXX_FLAGS 
+		"${CMAKE_C_FLAGS}" 
+		CACHE STRING "C flags for Raspberry PI 4"
+	)
+elseif(RASPBERRY_VERSION VERSION_GREATER 2)
+	set(CMAKE_C_FLAGS 
+		"-mcpu=cortex-a53 -mfpu=neon-vfpv4 -mfloat-abi=hard ${COMMON_FLAGS}" 
+		CACHE STRING "C flags for Raspberry PI 3"
+	)
+	set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" 
+		CACHE STRING "CPP flags for Raspberry PI 3"
+	)
+elseif(RASPBERRY_VERSION VERSION_GREATER 1)
+	set(CMAKE_C_FLAGS 
+		"-mcpu=cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard ${COMMON_FLAGS}" 
+		CACHE STRING "C flags for Raspberry PI 2"
+	)
+	set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" 
+		CACHE STRING "CPP flags for Raspberry PI 2"
+	)
+else()
+	set(CMAKE_C_FLAGS 
+		"-mcpu=arm1176jzf-s -mfpu=vfp -mfloat-abi=hard ${COMMON_FLAGS}" 
+		CACHE STRING "C flags for Raspberry PI 1 B+ Zero"
+	)
+	set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS}" 
+		CACHE STRING "CPP flags for Raspberry PI 1 B+ Zero"
+	)
+endif()
+
+set(CMAKE_FIND_ROOT_PATH 
+	"${CMAKE_INSTALL_PREFIX};${CMAKE_PREFIX_PATH};${CMAKE_SYSROOT}"
+)
+
+
+# search for programs in the build host directories
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries and headers in the target directories
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

cmake/scripts/BeagleBoneBlack/create_cmake_debug_cfg.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+counter=0
+while [ ${counter} -lt 5 ]
+do
+	cd ..
+	if [ -f "cmake_build_config.py" ];then
+		break
+	fi
+	counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+	echo "cmake_build_config.py not found in upper directories!"
+	exit 1
+fi
+
+os_fsfw="linux"
+tgt_bsp="arm/beagleboneblack"
+build_generator=""
+builddir="build-Debug-BBB"
+defines="LINUX_CROSS_COMPILE=OFF"
+if [ "${OS}" = "Windows_NT" ]; then
+	build_generator="MinGW Makefiles"
+# Could be other OS but this works for now.
+else
+	build_generator="Unix Makefiles"
+fi
+
+python3 cmake_build_config.py -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+		-l "${builddir}" -d "${defines}"

cmake/scripts/BeagleBoneBlack/crosscompile/bbb_path_helper.sh

@@ -0,0 +1,3 @@
+export PATH=$PATH:"$HOME/beaglebone/<cross_compiler_path>/bin"
+export CROSS_COMPILE="arm-linux-gnueabihf"
+export BBB_ROOTFS="${HOME}/raspberrypi/rootfs"

cmake/scripts/BeagleBoneBlack/crosscompile/create_cmake_debug_cfg.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+counter=0
+while [ ${counter} -lt 5 ]
+do
+	cd ..
+	if [ -f "cmake_build_config.py" ];then
+		break
+	fi
+	counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+	echo "cmake_build_config.py not found in upper directories!"
+	exit 1
+fi
+
+os_fsfw="linux"
+tgt_bsp="arm/beagleboneblack"
+build_generator=""
+builddir="build-Debug-BBB"
+defines="LINUX_CROSS_COMPILE=ON"
+if [ "${OS}" = "Windows_NT" ]; then
+	build_generator="MinGW Makefiles"
+# Could be other OS but this works for now.
+else
+	build_generator="Unix Makefiles"
+fi
+
+python3 cmake_build_config.py -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+		-l "${builddir}" -d "${defines}"

cmake/scripts/BeagleBoneBlack/crosscompile/create_cmake_release_cfg.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+counter=0
+while [ ${counter} -lt 5 ]
+do
+	cd ..
+	if [ -f "cmake_build_config.py" ];then
+		break
+	fi
+	counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+	echo "cmake_build_config.py not found in upper directories!"
+	exit 1
+fi
+
+os_fsfw="linux"
+tgt_bsp="arm/beagleboneblack"
+build_generator=""
+builddir="build-Release-BBB"
+defines="LINUX_CROSS_COMPILE=ON"
+if [ "${OS}" = "Windows_NT" ]; then
+	build_generator="MinGW Makefiles"
+# Could be other OS but this works for now.
+else
+	build_generator="Unix Makefiles"
+fi
+
+python3 cmake_build_config.py -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+		-l "${builddir}" -d "${defines}"

cmake/scripts/BeagleBoneBlack/crosscompile/create_cmake_relwithdeb_cfg.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+counter=0
+while [ ${counter} -lt 5 ]
+do
+	cd ..
+	if [ -f "cmake_build_config.py" ];then
+		break
+	fi
+	counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+	echo "cmake_build_config.py not found in upper directories!"
+	exit 1
+fi
+
+os_fsfw="linux"
+tgt_bsp="arm/beagleboneblack"
+build_generator=""
+builddir="build-Release-BBB"
+defines="LINUX_CROSS_COMPILE=ON"
+if [ "${OS}" = "Windows_NT" ]; then
+	build_generator="MinGW Makefiles"
+# Could be other OS but this works for now.
+else
+	build_generator="Unix Makefiles"
+fi
+
+python3 cmake_build_config.py -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+		-l "${builddir}" -d "${defines}"

cmake/scripts/Host/create_cmake_debug_cfg.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+counter=0
+while [ ${counter} -lt 5 ]
+do
+	cd ..
+	if [ -f "cmake_build_config.py" ];then
+		break
+	fi
+	counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+	echo "create_cmake_cfg.sh not found in upper directories!"
+	exit 1
+fi
+
+build_generator=""
+build_dir="build-Debug-Host"
+os_fsfw="host"
+if [ "${OS}" = "Windows_NT" ]; then
+	build_generator="MinGW Makefiles"
+# Could be other OS but this works for now.
+else
+	build_generator="Unix Makefiles"
+fi
+
+python3 cmake_build_config.py -o "${os_fsfw}" -g "${build_generator}" -b "debug" -l"${build_dir}"