Merge pull request 'Merge development into master for v2.0.0' (#493) from development into master

Reviewed-on: fsfw/fsfw#493

CHANGELOG

@@ -1,17 +1,81 @@
-## Changes from ASTP 1.0.0 to 1.1.0
+# Changed from ASTP 1.1.0 to 1.2.0
+
+## API Changes
+
+### FSFW Architecture
+
+- New src folder which contains all source files except the HAL, contributed code and test code
+- External and internal API mostly stayed the same
+- Folder names are now all smaller case: internalError was renamed to internalerror and
+  FreeRTOS was renamed to freertos
+- Warning if optional headers are used but the modules was not added to the source files to compile
+
+### HAL
+
+- HAL added back into FSFW. It is tightly bound to the FSFW, and compiling it as a static library
+  made using it more complicated than necessary
+
+## Bugfixes
+
+### FreeRTOS QueueMapManager
+
+- Fixed a bug which causes the first generated Queue ID to be invalid
+
+## Enhancements
+
+### FSFW Architecture
+
+- See API changes chapter. This change will keep the internal API consistent in the future
+
+# Changes from ASTP 1.0.0 to 1.1.0
+
+## API Changes
 
 ### PUS
 
 - Added PUS C support
+- SUBSYSTEM_IDs added for PUS Services
+- Added new Parameter which must be defined in config: fsfwconfig::FSFW_MAX_TM_PACKET_SIZE
+
+### ObjectManager
+
+ - ObjectManager is now a singelton
+
 
 ### Configuration
 
 - Additional configuration option fsfwconfig::FSFW_MAX_TM_PACKET_SIZE which 
   need to be specified in FSFWConfig.h
 
+### CMake
+
+- Changed Cmake FSFW_ADDITIONAL_INC_PATH to FSFW_ADDITIONAL_INC_PATHS
+
+## Bugfixes 
+
+- timemanager/TimeStamperIF.h: Timestamp config was not used correctly, leading to different timestamp sizes than configured in fsfwconfig::FSFW_MISSION_TIMESTAMP_SIZE
+- TCP server fixes
+
+## Enhancements
+
+### FreeRTOS Queue Handles
+
+- Fixed an internal issue how FreeRTOS MessageQueues were handled
+
+### Linux OSAL
+
+- Better printf error messages
+
+### CMake
+
+- Check for C++11 as mininimum required Version
+
+### Debug Output
+
+- Changed Warning color to magenta, which is well readable on both dark and light mode IDEs
 
 
-## Changes from ASTP 0.0.1 to 1.0.0
+# Changes from ASTP 0.0.1 to 1.0.0
 
 ### Host OSAL
 

CMakeLists.txt

@@ -3,20 +3,33 @@ cmake_minimum_required(VERSION 3.13)
 option(FSFW_GENERATE_SECTIONS
     "Generate function and data sections. Required to remove unused code" ON
 )
-
 if(FSFW_GENERATE_SECTIONS)
     option(FSFW_REMOVE_UNUSED_CODE "Remove unused code" ON)
 endif()
 
 option(FSFW_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
 # Options to exclude parts of the FSFW from compilation.
-option(FSFW_USE_RMAP "Compile with RMAP" ON)
+option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" ON)
-option(FSFW_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+option(FSFW_ADD_UNITTESTS "Add regular unittests. Requires Catch2" OFF)
+option(FSFW_ADD_HAL "Add Hardware Abstraction Layer" ON)
+
+# Optional sources
+option(FSFW_ADD_PUS "Compile with PUS sources" ON)
+option(FSFW_ADD_MONITORING "Compile with monitoring components" ON)
+
+option(FSFW_ADD_RMAP "Compile with RMAP" OFF)
+option(FSFW_ADD_DATALINKLAYER "Compile with Data Link Layer" OFF)
+option(FSFW_ADD_COORDINATES "Compile with coordinate components" OFF)
+option(FSFW_ADD_TMSTORAGE "Compile with tm storage components" OFF)
+
+# Contrib sources
+option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 
 set(LIB_FSFW_NAME fsfw)
 add_library(${LIB_FSFW_NAME})
+set(FSFW_CORE_INC_PATH "inc")
 
-set_property(CACHE OS_FSFW PROPERTY STRINGS host linux rtems freertos)
+set_property(CACHE FSFW_OSAL PROPERTY STRINGS host linux rtems freertos)
 
 if(NOT CMAKE_CXX_STANDARD)
     set(CMAKE_CXX_STANDARD 11)
@@ -25,38 +38,45 @@ elseif(${CMAKE_CXX_STANDARD} LESS 11)
     message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++11 support")
 endif()
 
-if(NOT OS_FSFW)
+# Backwards comptability
-	message(STATUS "No OS for FSFW via OS_FSFW set. Assuming host OS")
+if(OS_FSFW AND NOT FSFW_OSAL)
+    message(WARNING "Please pass the FSFW OSAL as FSFW_OSAL instead of OS_FSFW")
+    set(FSFW_OSAL OS_FSFW)
+endif()
+
+if(NOT FSFW_OSAL)
+	message(STATUS "No OS for FSFW via FSFW_OSAL set. Assuming host OS")
 	# Assume host OS and autodetermine from OS_FSFW
 	if(UNIX)
-		set(OS_FSFW  "linux" 
+		set(FSFW_OSAL  "linux" 
 			CACHE STRING 
 			"OS abstraction layer used in the FSFW"
 		)
 	elseif(WIN32)
-		set(OS_FSFW  "host" 
+		set(FSFW_OSAL  "host" 
 			CACHE STRING "OS abstraction layer used in the FSFW"
 		)
 	endif()
 
 endif()
 
-set(FSFW_OSAL_DEFINITION FSFW_HOST)
+set(FSFW_OSAL_DEFINITION FSFW_OSAL_HOST)
 
-if(${OS_FSFW} STREQUAL host)
+if(FSFW_OSAL MATCHES host)
     set(OS_FSFW_NAME "Host")
-elseif(${OS_FSFW} STREQUAL linux)
+    set(FSFW_OSAL_HOST ON)
+elseif(FSFW_OSAL MATCHES linux)
     set(OS_FSFW_NAME "Linux")
-	set(FSFW_OSAL_DEFINITION FSFW_LINUX)
+    set(FSFW_OSAL_LINUX ON)
-elseif(${OS_FSFW} STREQUAL  freertos)
+elseif(FSFW_OSAL MATCHES freertos)
     set(OS_FSFW_NAME "FreeRTOS")
-	set(FSFW_OSAL_DEFINITION FSFW_FREERTOS)
+    set(FSFW_OSAL_FREERTOS ON)
     target_link_libraries(${LIB_FSFW_NAME} PRIVATE
         ${LIB_OS_NAME}
     )
-elseif(${OS_FSFW} STREQUAL rtems)
+elseif(FSFW_OSAL STREQUAL rtems)
     set(OS_FSFW_NAME "RTEMS")
-    set(FSFW_OSAL_DEFINITION FSFW_RTEMS)
+    set(FSFW_OSAL_RTEMS ON)
 else()
     message(WARNING
         "Invalid operating system for FSFW specified! Setting to host.."
@@ -65,60 +85,14 @@ else()
     set(OS_FSFW "host")
 endif()
 
-target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
-    ${FSFW_OSAL_DEFINITION}
-)
-
-target_compile_definitions(${LIB_FSFW_NAME} INTERFACE
-    ${FSFW_OSAL_DEFINITION}
-)
-
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
-add_subdirectory(action)
+add_subdirectory(src)
-add_subdirectory(container)
+add_subdirectory(tests)
-add_subdirectory(controller)
+if(FSFW_ADD_HAL)
-add_subdirectory(coordinates)
+    add_subdirectory(hal)
-
-if(FSFW_USE_DATALINKLAYER)
-	add_subdirectory(datalinklayer)
 endif()
-
+add_subdirectory(contrib)
-add_subdirectory(datapool)
-add_subdirectory(datapoollocal)
-add_subdirectory(housekeeping)
-add_subdirectory(devicehandlers)
-add_subdirectory(events)
-add_subdirectory(fdir)
-add_subdirectory(globalfunctions)
-add_subdirectory(health)
-add_subdirectory(internalError)
-add_subdirectory(ipc)
-add_subdirectory(memory)
-add_subdirectory(modes)
-add_subdirectory(monitoring)
-add_subdirectory(objectmanager)
-add_subdirectory(osal)
-add_subdirectory(parameters)
-add_subdirectory(power)
-add_subdirectory(pus)
-
-if(FSFW_USE_RMAP)
-	add_subdirectory(rmap)
-endif()
-
-add_subdirectory(serialize)
-add_subdirectory(serviceinterface)
-add_subdirectory(storagemanager)
-add_subdirectory(subsystem)
-add_subdirectory(tasks)
-add_subdirectory(tcdistribution)
-add_subdirectory(thermal)
-add_subdirectory(timemanager)
-add_subdirectory(tmstorage)
-add_subdirectory(tmtcpacket)
-add_subdirectory(tmtcservices)
-add_subdirectory(unittest)
 
 # The project CMakeLists file has to set the FSFW_CONFIG_PATH and add it.
 # If this is not given, we include the default configuration and emit a warning.
@@ -191,6 +165,7 @@ endif()
 target_include_directories(${LIB_FSFW_NAME} INTERFACE 
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
 	${FSFW_ADD_INC_PATHS_ABS}
 )
 
@@ -200,6 +175,7 @@ target_include_directories(${LIB_FSFW_NAME} INTERFACE
 target_include_directories(${LIB_FSFW_NAME} PRIVATE 
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
 	${FSFW_ADD_INC_PATHS_ABS}
 )
 

FSFW.h

@@ -1,7 +0,0 @@
-#ifndef FSFW_FSFW_H_
-#define FSFW_FSFW_H_
-
-#include "FSFWConfig.h"
-
-
-#endif /* FSFW_FSFW_H_ */

FSFWVersion.h

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

README.md

@@ -1,4 +1,4 @@
-![FSFW Logo](logo/FSFW_Logo_V3_bw.png)
+![FSFW Logo](misc/logo/FSFW_Logo_V3_bw.png)
 
 # Flight Software Framework (FSFW)
 

contrib/CMakeLists.txt

@@ -0,0 +1,9 @@
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw_contrib)

contrib/fsfw_contrib/CMakeLists.txt

@@ -0,0 +1,11 @@
+if(FSFW_ADD_SGP4_PROPAGATOR)
+    target_sources(${LIB_FSFW_NAME} PRIVATE
+        sgp4/sgp4unit.cpp
+    )
+    target_include_directories(${LIB_FSFW_NAME} PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
+    )
+    target_include_directories(${LIB_FSFW_NAME} INTERFACE
+        ${CMAKE_CURRENT_SOURCE_DIR}/sgp4
+    )
+endif()

datapoollocal/datapoollocal.h

@@ -1,12 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
-#define FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
-
-/* Collected related headers */
-#include "LocalPoolVariable.h"
-#include "LocalPoolVector.h"
-#include "StaticLocalDataSet.h"
-#include "LocalDataSet.h"
-#include "SharedLocalDataSet.h"
-
-
-#endif /* FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_ */

defaultcfg/fsfwconfig/fsfwconfig.mk

@@ -1,15 +0,0 @@
-CXXSRC += $(wildcard $(CURRENTPATH)/ipc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/objects/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/pollingsequence/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/events/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/tmtc/*.cpp)
-CXXSRC += $(wildcard $(CURRENTPATH)/devices/*.cpp)
-
-INCLUDES += $(CURRENTPATH)
-INCLUDES += $(CURRENTPATH)/objects
-INCLUDES += $(CURRENTPATH)/returnvalues
-INCLUDES += $(CURRENTPATH)/tmtc
-INCLUDES += $(CURRENTPATH)/events
-INCLUDES += $(CURRENTPATH)/devices
-INCLUDES += $(CURRENTPATH)/pollingsequence
-INCLUDES += $(CURRENTPATH)/ipc

events/CMakeLists.txt

@@ -1,7 +0,0 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		EventManager.cpp
-		EventMessage.cpp
-)
-
-add_subdirectory(eventmatching)

fsfw.mk

@@ -1,75 +0,0 @@
-# This submake file needs to be included by the primary Makefile.
-# This file needs FRAMEWORK_PATH and OS_FSFW set correctly by another Makefile.
-# Valid API settings: rtems, linux, freeRTOS, host
-
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/action/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/container/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/contrib/sgp4/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/controller/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/coordinates/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datalinklayer/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapool/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/datapoollocal/internal/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/housekeeping/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/devicehandlers/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/events/eventmatching/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/fdir/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/matching/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/globalfunctions/math/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/health/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/internalError/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/ipc/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/memory/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/modes/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/monitoring/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/objectmanager/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/*.cpp)
-
-# select the OS
-ifeq ($(OS_FSFW),rtems)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/rtems/*.cpp)
-
-else ifeq ($(OS_FSFW),linux)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/linux/*.cpp)
-
-else ifeq ($(OS_FSFW),freeRTOS)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
-
-else ifeq ($(OS_FSFW),host)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
-ifeq ($(OS),Windows_NT)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/windows/*.cpp)
-else
-# For now, the linux UDP bridge sources needs to be included manually by upper makefile
-# for host OS because we can't be sure the OS is linux.
-# Following lines can be used to do this:
-# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TcUnixUdpPollingTask.cpp
-# CXXSRC += $(FRAMEWORK_PATH)/osal/linux/TmTcUnixUdpBridge.cpp
-endif
-
-else
-$(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
-endif
-
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/power/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/returnvalues/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/rmap/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/serialize/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/serviceinterface/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/storagemanager/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/subsystem/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/subsystem/modes/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tasks/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tcdistribution/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/thermal/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/timemanager/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmstorage/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)

globalfunctions/DleEncoder.cpp

@@ -1,124 +0,0 @@
-#include "../globalfunctions/DleEncoder.h"
-
-DleEncoder::DleEncoder() {}
-
-DleEncoder::~DleEncoder() {}
-
-ReturnValue_t DleEncoder::encode(const uint8_t* sourceStream,
-		size_t sourceLen, uint8_t* destStream, size_t maxDestLen,
-		size_t* encodedLen, bool addStxEtx) {
-	if (maxDestLen < 2) {
-		return STREAM_TOO_SHORT;
-	}
-	size_t encodedIndex = 0, sourceIndex = 0;
-	uint8_t nextByte;
-	if (addStxEtx) {
-		destStream[0] = STX_CHAR;
-		++encodedIndex;
-	}
-
-	while (encodedIndex < maxDestLen and sourceIndex < sourceLen)
-	{
-		nextByte = sourceStream[sourceIndex];
-		// STX, ETX and CR characters in the stream need to be escaped with DLE
-		if (nextByte == STX_CHAR or nextByte == ETX_CHAR or nextByte == CARRIAGE_RETURN) {
-			if (encodedIndex + 1 >= maxDestLen) {
-				return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				/* Escaped byte will be actual byte + 0x40. This prevents
-				 * STX, ETX, and carriage return characters from appearing
-				 * in the encoded data stream at all, so when polling an
-				 * encoded stream, the transmission can be stopped at ETX.
-				 * 0x40 was chosen at random with special requirements:
-				 *  - Prevent going from one control char to another
-				 *  - Prevent overflow for common characters */
-				destStream[encodedIndex] = nextByte + 0x40;
-			}
-		}
-		// DLE characters are simply escaped with DLE.
-		else if (nextByte == DLE_CHAR) {
-			if (encodedIndex + 1 >= maxDestLen) {
-			    return STREAM_TOO_SHORT;
-			}
-			else {
-				destStream[encodedIndex] = DLE_CHAR;
-				++encodedIndex;
-				destStream[encodedIndex] = DLE_CHAR;
-			}
-		}
-		else {
-			destStream[encodedIndex] = nextByte;
-		}
-		++encodedIndex;
-		++sourceIndex;
-	}
-
-	if (sourceIndex == sourceLen and encodedIndex < maxDestLen) {
-		if (addStxEtx) {
-			destStream[encodedIndex] = ETX_CHAR;
-			++encodedIndex;
-		}
-		*encodedLen = encodedIndex;
-		return RETURN_OK;
-	}
-	else {
-		return STREAM_TOO_SHORT;
-	}
-}
-
-ReturnValue_t DleEncoder::decode(const uint8_t *sourceStream,
-		size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-		size_t maxDestStreamlen, size_t *decodedLen) {
-	size_t encodedIndex = 0, decodedIndex = 0;
-	uint8_t nextByte;
-	if (*sourceStream != STX_CHAR) {
-		return DECODING_ERROR;
-	}
-	++encodedIndex;
-
-	while ((encodedIndex < sourceStreamLen) && (decodedIndex < maxDestStreamlen)
-			&& (sourceStream[encodedIndex] != ETX_CHAR)
-			&& (sourceStream[encodedIndex] != STX_CHAR)) {
-		if (sourceStream[encodedIndex] == DLE_CHAR) {
-			nextByte = sourceStream[encodedIndex + 1];
-			// The next byte is a DLE character that was escaped by another
-			// DLE character, so we can write it to the destination stream.
-			if (nextByte == DLE_CHAR) {
-				destStream[decodedIndex] = nextByte;
-			}
-			else {
-			    /* The next byte is a STX, DTX or 0x0D character which
-			     * was escaped by a DLE character. The actual byte was
-				 * also encoded by adding + 0x40 to prevent having control chars,
-				 * in the stream at all, so we convert it back. */
-				if (nextByte == 0x42 or nextByte == 0x43 or nextByte == 0x4D) {
-					destStream[decodedIndex] = nextByte - 0x40;
-				}
-				else {
-				    return DECODING_ERROR;
-				}
-			}
-			++encodedIndex;
-		}
-		else {
-			destStream[decodedIndex] = sourceStream[encodedIndex];
-		}
-
-		++encodedIndex;
-		++decodedIndex;
-	}
-
-	if (sourceStream[encodedIndex] != ETX_CHAR) {
-		*readLen = ++encodedIndex;
-		return DECODING_ERROR;
-	}
-	else {
-		*readLen = ++encodedIndex;
-		*decodedLen = decodedIndex;
-		return RETURN_OK;
-	}
-}
-

globalfunctions/DleEncoder.h

@@ -1,79 +0,0 @@
-#ifndef FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-#define FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-/**
- * @brief   This DLE Encoder (Data Link Encoder) can be used to encode and
- *          decode arbitrary data with ASCII control characters
- * @details
- * List of control codes:
- * https://en.wikipedia.org/wiki/C0_and_C1_control_codes
- *
- * This encoder can be used to achieve a basic transport layer when using
- * char based transmission systems.
- * The passed source strean is converted into a encoded stream by adding
- * a STX marker at the start of the stream and an ETX marker at the end of
- * the stream. Any STX, ETX, DLE and CR occurrences in the source stream are
- * escaped by a DLE character. The encoder also replaces escaped control chars
- * by another char, so STX, ETX and CR should not appear anywhere in the actual
- * encoded data stream.
- *
- * When using a strictly char based reception of packets encoded with DLE,
- * STX can be used to notify a reader that actual data will start to arrive
- * while ETX can be used to notify the reader that the data has ended.
- */
-class DleEncoder: public HasReturnvaluesIF {
-private:
-	DleEncoder();
-	virtual ~DleEncoder();
-
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::DLE_ENCODER;
-	static constexpr ReturnValue_t STREAM_TOO_SHORT = MAKE_RETURN_CODE(0x01);
-	static constexpr ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(0x02);
-
-	//! Start Of Text character. First character is encoded stream
-	static constexpr uint8_t STX_CHAR = 0x02;
-	//! End Of Text character. Last character in encoded stream
-	static constexpr uint8_t ETX_CHAR = 0x03;
-	//! Data Link Escape character. Used to escape STX, ETX and DLE occurrences
-	//! in the source stream.
-	static constexpr uint8_t DLE_CHAR = 0x10;
-	static constexpr uint8_t CARRIAGE_RETURN = 0x0D;
-
-    /**
-     * Encodes the give data stream by preceding it with the STX marker
-     * and ending it with an ETX marker. STX, ETX and DLE characters inside
-     * the stream are escaped by DLE characters and also replaced by adding
-     * 0x40 (which is reverted in the decoding process).
-     * @param sourceStream
-     * @param sourceLen
-     * @param destStream
-     * @param maxDestLen
-     * @param encodedLen
-     * @param addStxEtx
-     * Adding STX and ETX can be omitted, if they are added manually.
-     * @return
-     */
-    static ReturnValue_t encode(const uint8_t *sourceStream, size_t sourceLen,
-            uint8_t *destStream, size_t maxDestLen, size_t *encodedLen,
-            bool addStxEtx = true);
-
-    /**
-     * Converts an encoded stream back.
-     * @param sourceStream
-     * @param sourceStreamLen
-     * @param readLen
-     * @param destStream
-     * @param maxDestStreamlen
-     * @param decodedLen
-     * @return
-     */
-	static ReturnValue_t decode(const uint8_t *sourceStream,
-			size_t sourceStreamLen, size_t *readLen, uint8_t *destStream,
-			size_t maxDestStreamlen, size_t *decodedLen);
-};
-
-#endif /* FRAMEWORK_GLOBALFUNCTIONS_DLEENCODER_H_ */

hal/CMakeLists.txt

@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 3.13)
+
+# Can also be changed by upper CMakeLists.txt file
+find_library(LIB_FSFW_NAME fsfw REQUIRED)
+
+option(FSFW_HAL_ADD_LINUX "Add the Linux HAL to the sources. Required gpiod library" OFF)
+option(FSFW_HAL_ADD_RASPBERRY_PI "Add Raspberry Pi specific code to the sources" OFF)
+option(FSFW_HAL_ADD_STM32H7 "Add the STM32H7 HAL to the sources" OFF)
+option(FSFW_HAL_WARNING_SHADOW_LOCAL_GCC "Enable -Wshadow=local warning in GCC" ON)
+
+set(LINUX_HAL_PATH_NAME linux)
+set(STM32H7_PATH_NAME stm32h7)
+
+add_subdirectory(src)
+
+foreach(INCLUDE_PATH ${FSFW_HAL_ADDITIONAL_INC_PATHS})
+    if(IS_ABSOLUTE ${INCLUDE_PATH})
+        set(CURR_ABS_INC_PATH "${INCLUDE_PATH}")
+    else()
+        get_filename_component(CURR_ABS_INC_PATH
+            ${INCLUDE_PATH} REALPATH BASE_DIR ${CMAKE_SOURCE_DIR})
+    endif()
+
+    if(CMAKE_VERBOSE)
+        message(STATUS "FSFW include path: ${CURR_ABS_INC_PATH}")
+    endif()
+
+    list(APPEND FSFW_HAL_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_ADD_INC_PATHS_ABS}
+)
+
+target_compile_definitions(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_DEFINES}
+)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_HAL_LINK_LIBS}
+)

hal/src/CMakeLists.txt

@@ -0,0 +1,9 @@
+target_include_directories(${LIB_FSFW_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_include_directories(${LIB_FSFW_NAME} INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw_hal)

hal/src/fsfw_hal/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_subdirectory(devicehandlers)
+add_subdirectory(common)
+
+if(FSFW_HAL_ADD_LINUX)
+    add_subdirectory(linux)
+endif()
+
+if(FSFW_HAL_ADD_STM32H7)
+    add_subdirectory(stm32h7)
+endif()

hal/src/fsfw_hal/common/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(gpio)

hal/src/fsfw_hal/common/gpio/CMakeLists.txt

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

hal/src/fsfw_hal/common/gpio/GpioCookie.cpp

@@ -0,0 +1,50 @@
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+GpioCookie::GpioCookie() {
+}
+
+ReturnValue_t GpioCookie::addGpio(gpioId_t gpioId, GpioBase* gpioConfig) {
+    if (gpioConfig == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "GpioCookie::addGpio: gpioConfig is nullpointer" << std::endl;
+#else
+        sif::printWarning("GpioCookie::addGpio: gpioConfig is nullpointer\n");
+#endif
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    auto gpioMapIter = gpioMap.find(gpioId);
+    if(gpioMapIter == gpioMap.end()) {
+        auto statusPair = gpioMap.emplace(gpioId, gpioConfig);
+        if (statusPair.second == false) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "GpioCookie::addGpio: Failed to add GPIO " << gpioId <<
+                    " to GPIO map" << std::endl;
+#else
+            sif::printWarning("GpioCookie::addGpio: Failed to add GPIO %d to GPIO map\n", gpioId);
+#endif
+#endif
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "GpioCookie::addGpio: GPIO already exists in GPIO map " << std::endl;
+#else
+    sif::printWarning("GpioCookie::addGpio: GPIO already exists in GPIO map\n");
+#endif
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+GpioMap GpioCookie::getGpioMap() const {
+    return gpioMap;
+}
+
+GpioCookie::~GpioCookie() {
+    for(auto& config: gpioMap) {
+        delete(config.second);
+    }
+}

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

@@ -0,0 +1,41 @@
+#ifndef COMMON_GPIO_GPIOCOOKIE_H_
+#define COMMON_GPIO_GPIOCOOKIE_H_
+
+#include "GpioIF.h"
+#include "gpioDefinitions.h"
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+/**
+ * @brief   Cookie for the GpioIF. Allows the GpioIF to determine which
+ * 			GPIOs to initialize and whether they should be configured as in- or
+ * 			output.
+ * @details	One GpioCookie can hold multiple GPIO configurations. To add a new
+ * 			GPIO configuration to a GpioCookie use the GpioCookie::addGpio
+ * 			function.
+ *
+ * @author 	J. Meier
+ */
+class GpioCookie: public CookieIF {
+public:
+
+    GpioCookie();
+
+    virtual ~GpioCookie();
+
+    ReturnValue_t addGpio(gpioId_t gpioId, GpioBase* gpioConfig);
+
+    /**
+     * @brief	Get map with registered GPIOs.
+     */
+    GpioMap getGpioMap() const;
+
+private:
+    /**
+     * Returns a copy of the internal GPIO map.
+     */
+    GpioMap gpioMap;
+};
+
+#endif /* COMMON_GPIO_GPIOCOOKIE_H_ */

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

@@ -0,0 +1,54 @@
+#ifndef COMMON_GPIO_GPIOIF_H_
+#define COMMON_GPIO_GPIOIF_H_
+
+#include "gpioDefinitions.h"
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/devicehandlers/CookieIF.h>
+
+class GpioCookie;
+
+/**
+ * @brief	This class defines the interface for objects requiring the control
+ * 			over GPIOs.
+ * @author	J. Meier
+ */
+class GpioIF : public HasReturnvaluesIF {
+public:
+
+	virtual ~GpioIF() {};
+
+	/**
+	 * @brief   Called by the GPIO using object.
+	 * @param cookie	Cookie specifying informations of the GPIOs required
+	 * 					by a object.
+	 */
+	virtual ReturnValue_t addGpios(GpioCookie* cookie) = 0;
+
+	/**
+	 * @brief	By implementing this function a child must provide the
+	 * 			functionality to pull a certain GPIO to high logic level.
+	 *
+	 * @param gpioId	A unique number which specifies the GPIO to drive.
+	 * @return  Returns RETURN_OK for success. This should never return RETURN_FAILED.
+	 */
+	virtual ReturnValue_t pullHigh(gpioId_t gpioId) = 0;
+
+	/**
+	 * @brief	By implementing this function a child must provide the
+	 * 			functionality to pull a certain GPIO to low logic level.
+	 *
+	 * @param gpioId	A unique number which specifies the GPIO to drive.
+	 */
+	virtual ReturnValue_t pullLow(gpioId_t gpioId) = 0;
+
+	/**
+     * @brief   This function requires a child to implement the functionality to read the state of
+     *          an ouput or input gpio.
+     *
+     * @param gpioId    A unique number which specifies the GPIO to read.
+     * @param gpioState State of GPIO will be written to this pointer.
+     */
+    virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) = 0;
+};
+
+#endif /* COMMON_GPIO_GPIOIF_H_ */

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

@@ -0,0 +1,140 @@
+#ifndef COMMON_GPIO_GPIODEFINITIONS_H_
+#define COMMON_GPIO_GPIODEFINITIONS_H_
+
+#include <string>
+#include <unordered_map>
+#include <map>
+
+using gpioId_t = uint16_t;
+
+namespace gpio {
+
+enum Levels {
+    LOW = 0,
+    HIGH = 1
+};
+
+enum Direction {
+    IN = 0,
+    OUT = 1
+};
+
+enum GpioOperation {
+    READ,
+    WRITE
+};
+
+enum GpioTypes {
+    NONE,
+    GPIO_REGULAR_BY_CHIP,
+    GPIO_REGULAR_BY_LABEL,
+    CALLBACK
+};
+
+static constexpr gpioId_t NO_GPIO = -1;
+
+using gpio_cb_t = void (*) (gpioId_t gpioId, gpio::GpioOperation gpioOp, int value, void* args);
+
+}
+
+/**
+ * @brief   Struct containing information about the GPIO to use. This is
+ *          required by the libgpiod to access and drive a GPIO.
+ * @param chipname      String of the chipname specifying the group which contains the GPIO to
+ *                      access. E.g. gpiochip0. To detect names of GPIO groups run gpiodetect on
+ *                      the linux command line.
+ * @param lineNum       The offset of the GPIO within the GPIO group.
+ * @param consumer      Name of the consumer. Simply a description of the GPIO configuration.
+ * @param direction     Specifies whether the GPIO should be used as in- or output.
+ * @param initValue     Defines the initial state of the GPIO when configured as output.
+ *                      Only required for output GPIOs.
+ * @param lineHandle    The handle returned by gpiod_chip_get_line will be later written to this
+ *                      pointer.
+ */
+class GpioBase {
+public:
+
+    GpioBase() = default;
+
+    GpioBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
+            int initValue):
+            gpioType(gpioType), consumer(consumer),direction(direction), initValue(initValue) {}
+
+    virtual~ GpioBase() {};
+
+    // Can be used to cast GpioBase to a concrete child implementation
+    gpio::GpioTypes gpioType = gpio::GpioTypes::NONE;
+    std::string consumer;
+    gpio::Direction direction = gpio::Direction::IN;
+    int initValue = 0;
+};
+
+class GpiodRegularBase: public GpioBase {
+public:
+    GpiodRegularBase(gpio::GpioTypes gpioType, std::string consumer, gpio::Direction direction,
+            int initValue, int lineNum): GpioBase(gpioType, consumer, direction, initValue),
+            lineNum(lineNum) {
+    }
+    int lineNum = 0;
+    struct gpiod_line* lineHandle = nullptr;
+};
+
+class GpiodRegularByChip: public GpiodRegularBase {
+public:
+    GpiodRegularByChip() :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP,
+                    std::string(), gpio::Direction::IN, gpio::LOW, 0) {
+    }
+
+    GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_,
+            gpio::Direction direction_, int initValue_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP,
+                    consumer_, direction_, initValue_, lineNum_),
+            chipname(chipname_){
+    }
+
+    GpiodRegularByChip(std::string chipname_, int lineNum_, std::string consumer_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP, consumer_,
+                    gpio::Direction::IN, gpio::LOW, lineNum_),
+            chipname(chipname_) {
+    }
+
+    std::string chipname;
+};
+
+class GpiodRegularByLabel: public GpiodRegularBase {
+public:
+    GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_,
+            gpio::Direction direction_, int initValue_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_,
+                    direction_, initValue_, lineNum_),
+            label(label_) {
+    }
+
+    GpiodRegularByLabel(std::string label_, int lineNum_, std::string consumer_) :
+            GpiodRegularBase(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL, consumer_,
+                    gpio::Direction::IN, gpio::LOW, lineNum_),
+            label(label_) {
+    }
+
+    std::string label;
+};
+
+class GpioCallback: public GpioBase {
+public:
+    GpioCallback(std::string consumer, gpio::Direction direction_, int initValue_,
+            gpio::gpio_cb_t callback, void* callbackArgs):
+            GpioBase(gpio::GpioTypes::CALLBACK, consumer, direction_, initValue_),
+            callback(callback), callbackArgs(callbackArgs) {}
+
+    gpio::gpio_cb_t callback = nullptr;
+    void* callbackArgs = nullptr;
+};
+
+
+using GpioMap = std::map<gpioId_t, GpioBase*>;
+using GpioUnorderedMap = std::unordered_map<gpioId_t, GpioBase*>;
+using GpioMapIter = GpioMap::iterator;
+using GpioUnorderedMapIter = GpioUnorderedMap::iterator;
+
+#endif /* LINUX_GPIO_GPIODEFINITIONS_H_ */

hal/src/fsfw_hal/common/spi/spiCommon.h

@@ -0,0 +1,17 @@
+#ifndef FSFW_HAL_COMMON_SPI_SPICOMMON_H_
+#define FSFW_HAL_COMMON_SPI_SPICOMMON_H_
+
+#include <cstdint>
+
+namespace spi {
+
+enum SpiModes: uint8_t {
+    MODE_0,
+    MODE_1,
+    MODE_2,
+    MODE_3
+};
+
+}
+
+#endif /* FSFW_HAL_COMMON_SPI_SPICOMMON_H_ */

hal/src/fsfw_hal/devicehandlers/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    GyroL3GD20Handler.cpp
+    MgmRM3100Handler.cpp
+    MgmLIS3MDLHandler.cpp
+)

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp

@@ -0,0 +1,287 @@
+#include "GyroL3GD20Handler.h"
+
+#include "fsfw/datapool/PoolReadGuard.h"
+
+#include <cmath>
+
+GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceCommunication,
+        CookieIF *comCookie, uint32_t transitionDelayMs):
+        DeviceHandlerBase(objectId, deviceCommunication, comCookie),
+        transitionDelayMs(transitionDelayMs), dataset(this) {
+#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
+    debugDivider = new PeriodicOperationDivider(3);
+#endif
+}
+
+GyroHandlerL3GD20H::~GyroHandlerL3GD20H() {}
+
+void GyroHandlerL3GD20H::doStartUp() {
+    if(internalState == InternalState::NONE) {
+        internalState = InternalState::CONFIGURE;
+    }
+
+    if(internalState == InternalState::CONFIGURE) {
+        if(commandExecuted) {
+            internalState = InternalState::CHECK_REGS;
+            commandExecuted = false;
+        }
+    }
+
+    if(internalState == InternalState::CHECK_REGS) {
+        if(commandExecuted) {
+            internalState = InternalState::NORMAL;
+            if(goNormalModeImmediately) {
+                setMode(MODE_NORMAL);
+            }
+            else {
+                setMode(_MODE_TO_ON);
+            }
+            commandExecuted = false;
+        }
+    }
+}
+
+void GyroHandlerL3GD20H::doShutDown() {
+    setMode(_MODE_POWER_DOWN);
+}
+
+ReturnValue_t GyroHandlerL3GD20H::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+    switch(internalState) {
+    case(InternalState::NONE):
+    case(InternalState::NORMAL): {
+        return NOTHING_TO_SEND;
+    }
+    case(InternalState::CONFIGURE): {
+        *id = L3GD20H::CONFIGURE_CTRL_REGS;
+        uint8_t command [5];
+        command[0] = L3GD20H::CTRL_REG_1_VAL;
+        command[1] = L3GD20H::CTRL_REG_2_VAL;
+        command[2] = L3GD20H::CTRL_REG_3_VAL;
+        command[3] = L3GD20H::CTRL_REG_4_VAL;
+        command[4] = L3GD20H::CTRL_REG_5_VAL;
+        return buildCommandFromCommand(*id, command, 5);
+    }
+    case(InternalState::CHECK_REGS): {
+        *id = L3GD20H::READ_REGS;
+        return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    default:
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        /* Might be a configuration error. */
+        sif::warning << "GyroL3GD20Handler::buildTransitionDeviceCommand: "
+                "Unknown internal state!" << std::endl;
+#else
+        sif::printDebug("GyroL3GD20Handler::buildTransitionDeviceCommand: "
+                "Unknown internal state!\n");
+#endif
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroHandlerL3GD20H::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+    *id = L3GD20H::READ_REGS;
+    return buildCommandFromCommand(*id, nullptr, 0);
+}
+
+ReturnValue_t GyroHandlerL3GD20H::buildCommandFromCommand(
+        DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+        size_t commandDataLen) {
+    switch(deviceCommand) {
+    case(L3GD20H::READ_REGS): {
+        commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK | L3GD20H::READ_MASK;
+        std::memset(commandBuffer + 1, 0, L3GD20H::READ_LEN);
+        rawPacket = commandBuffer;
+        rawPacketLen = L3GD20H::READ_LEN + 1;
+        break;
+    }
+    case(L3GD20H::CONFIGURE_CTRL_REGS): {
+        commandBuffer[0] = L3GD20H::CTRL_REG_1 | L3GD20H::AUTO_INCREMENT_MASK;
+        if(commandData == nullptr or commandDataLen != 5) {
+            return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+        }
+
+        ctrlReg1Value = commandData[0];
+        ctrlReg2Value = commandData[1];
+        ctrlReg3Value = commandData[2];
+        ctrlReg4Value = commandData[3];
+        ctrlReg5Value = commandData[4];
+
+        bool fsH = ctrlReg4Value & L3GD20H::SET_FS_1;
+        bool fsL = ctrlReg4Value & L3GD20H::SET_FS_0;
+
+        if(not fsH and not fsL) {
+            sensitivity = L3GD20H::SENSITIVITY_00;
+        }
+        else if(not fsH and fsL) {
+            sensitivity = L3GD20H::SENSITIVITY_01;
+        }
+        else {
+            sensitivity = L3GD20H::SENSITIVITY_11;
+        }
+
+        commandBuffer[1] = ctrlReg1Value;
+        commandBuffer[2] = ctrlReg2Value;
+        commandBuffer[3] = ctrlReg3Value;
+        commandBuffer[4] = ctrlReg4Value;
+        commandBuffer[5] = ctrlReg5Value;
+
+        rawPacket = commandBuffer;
+        rawPacketLen = 6;
+        break;
+    }
+    case(L3GD20H::READ_CTRL_REGS): {
+        commandBuffer[0] = L3GD20H::READ_START | L3GD20H::AUTO_INCREMENT_MASK |
+                L3GD20H::READ_MASK;
+
+        std::memset(commandBuffer + 1, 0, 5);
+        rawPacket = commandBuffer;
+        rawPacketLen = 6;
+        break;
+    }
+    default:
+        return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroHandlerL3GD20H::scanForReply(const uint8_t *start, size_t len,
+        DeviceCommandId_t *foundId, size_t *foundLen) {
+    // For SPI, the ID will always be the one of the last sent command
+    *foundId = this->getPendingCommand();
+    *foundLen = this->rawPacketLen;
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
+        const uint8_t *packet) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(id) {
+    case(L3GD20H::CONFIGURE_CTRL_REGS): {
+        commandExecuted = true;
+        break;
+    }
+    case(L3GD20H::READ_CTRL_REGS): {
+        if(packet[1] == ctrlReg1Value and packet[2] == ctrlReg2Value and
+                packet[3] == ctrlReg3Value and packet[4] == ctrlReg4Value and
+                packet[5] == ctrlReg5Value) {
+            commandExecuted = true;
+        }
+        else {
+            // Attempt reconfiguration
+            internalState = InternalState::CONFIGURE;
+            return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+        }
+        break;
+    }
+    case(L3GD20H::READ_REGS): {
+        if(packet[1] != ctrlReg1Value and packet[2] != ctrlReg2Value and
+                packet[3] != ctrlReg3Value and packet[4] != ctrlReg4Value and
+                packet[5] != ctrlReg5Value) {
+            return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+        }
+        else {
+            if(internalState == InternalState::CHECK_REGS) {
+                commandExecuted = true;
+            }
+        }
+
+        statusReg = packet[L3GD20H::STATUS_IDX];
+
+        int16_t angVelocXRaw = packet[L3GD20H::OUT_X_H] << 8 | packet[L3GD20H::OUT_X_L];
+        int16_t angVelocYRaw = packet[L3GD20H::OUT_Y_H] << 8 | packet[L3GD20H::OUT_Y_L];
+        int16_t angVelocZRaw = packet[L3GD20H::OUT_Z_H] << 8 | packet[L3GD20H::OUT_Z_L];
+        float angVelocX = angVelocXRaw * sensitivity;
+        float angVelocY = angVelocYRaw * sensitivity;
+        float angVelocZ = angVelocZRaw * sensitivity;
+
+        int8_t temperaturOffset = (-1) * packet[L3GD20H::TEMPERATURE_IDX];
+        float temperature = 25.0 + temperaturOffset;
+#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
+        if(debugDivider->checkAndIncrement()) {
+            /* Set terminal to utf-8 if there is an issue with micro printout. */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::info << "GyroHandlerL3GD20H: Angular velocities (deg/s):" << std::endl;
+            sif::info << "X: " << angVelocX << std::endl;
+            sif::info << "Y: " << angVelocY << std::endl;
+            sif::info << "Z: " << angVelocZ << std::endl;
+#else
+            sif::printInfo("GyroHandlerL3GD20H: Angular velocities (deg/s):\n");
+            sif::printInfo("X: %f\n", angVelocX);
+            sif::printInfo("Y: %f\n", angVelocY);
+            sif::printInfo("Z: %f\n", angVelocZ);
+#endif
+        }
+#endif
+
+        PoolReadGuard readSet(&dataset);
+        if(readSet.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+            if(std::abs(angVelocX) < this->absLimitX) {
+                dataset.angVelocX = angVelocX;
+                dataset.angVelocX.setValid(true);
+            }
+            else {
+                dataset.angVelocX.setValid(false);
+            }
+
+            if(std::abs(angVelocY) < this->absLimitY) {
+                dataset.angVelocY = angVelocY;
+                dataset.angVelocY.setValid(true);
+            }
+            else {
+                dataset.angVelocY.setValid(false);
+            }
+
+            if(std::abs(angVelocZ) < this->absLimitZ) {
+                dataset.angVelocZ = angVelocZ;
+                dataset.angVelocZ.setValid(true);
+            }
+            else {
+                dataset.angVelocZ.setValid(false);
+            }
+
+            dataset.temperature = temperature;
+            dataset.temperature.setValid(true);
+        }
+        break;
+    }
+    default:
+        return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+    }
+    return result;
+}
+
+
+uint32_t GyroHandlerL3GD20H::getTransitionDelayMs(Mode_t from, Mode_t to) {
+    return this->transitionDelayMs;
+}
+
+void GyroHandlerL3GD20H::setToGoToNormalMode(bool enable) {
+    this->goNormalModeImmediately = true;
+}
+
+ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(L3GD20H::ANG_VELOC_X, new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(L3GD20H::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(L3GD20H::TEMPERATURE, new PoolEntry<float>({0.0}));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void GyroHandlerL3GD20H::fillCommandAndReplyMap() {
+    insertInCommandAndReplyMap(L3GD20H::READ_REGS, 1, &dataset);
+    insertInCommandAndReplyMap(L3GD20H::CONFIGURE_CTRL_REGS, 1);
+    insertInCommandAndReplyMap(L3GD20H::READ_CTRL_REGS, 1);
+}
+
+void GyroHandlerL3GD20H::modeChanged() {
+    internalState = InternalState::NONE;
+}
+
+void GyroHandlerL3GD20H::setAbsoluteLimits(float limitX, float limitY, float limitZ) {
+    this->absLimitX = limitX;
+    this->absLimitY = limitY;
+    this->absLimitZ = limitZ;
+}

hal/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h

@@ -0,0 +1,99 @@
+#ifndef MISSION_DEVICES_GYROL3GD20HANDLER_H_
+#define MISSION_DEVICES_GYROL3GD20HANDLER_H_
+
+#include "fsfw/FSFW.h"
+#include "devicedefinitions/GyroL3GD20Definitions.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
+
+/**
+ * @brief 	Device Handler for the L3GD20H gyroscope sensor
+ *          (https://www.st.com/en/mems-and-sensors/l3gd20h.html)
+ * @details
+ * Advanced documentation:
+ * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/L3GD20H_Gyro
+ *
+ * Data is read big endian with the smallest possible range of 245 degrees per second.
+ */
+class GyroHandlerL3GD20H: public DeviceHandlerBase {
+public:
+    GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceCommunication,
+            CookieIF* comCookie, uint32_t transitionDelayMs);
+    virtual ~GyroHandlerL3GD20H();
+
+    /**
+     * Set the absolute limit for the values on the axis in degrees per second.
+     * The dataset values will be marked as invalid if that limit is exceeded
+     * @param xLimit
+     * @param yLimit
+     * @param zLimit
+     */
+    void setAbsoluteLimits(float limitX, float limitY, float limitZ);
+
+    /**
+     * @brief   Configure device handler to go to normal mode immediately
+     */
+    void setToGoToNormalMode(bool enable);
+protected:
+
+    /* DeviceHandlerBase overrides */
+    ReturnValue_t buildTransitionDeviceCommand(
+            DeviceCommandId_t *id) override;
+    void doStartUp() override;
+    void doShutDown() override;
+    ReturnValue_t buildNormalDeviceCommand(
+            DeviceCommandId_t *id) override;
+    ReturnValue_t buildCommandFromCommand(
+            DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+            size_t commandDataLen) override;
+    ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+            DeviceCommandId_t *foundId, size_t *foundLen) override;
+    virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+            const uint8_t *packet) override;
+
+    void fillCommandAndReplyMap() override;
+    void modeChanged() override;
+    virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+    ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+            LocalDataPoolManager &poolManager) override;
+
+private:
+    uint32_t transitionDelayMs = 0;
+    GyroPrimaryDataset dataset;
+
+    float absLimitX = L3GD20H::RANGE_DPS_00;
+    float absLimitY = L3GD20H::RANGE_DPS_00;
+    float absLimitZ = L3GD20H::RANGE_DPS_00;
+
+    enum class InternalState {
+        NONE,
+        CONFIGURE,
+        CHECK_REGS,
+        NORMAL
+    };
+    InternalState internalState = InternalState::NONE;
+    bool commandExecuted = false;
+
+    uint8_t statusReg = 0;
+    bool goNormalModeImmediately = false;
+
+    uint8_t ctrlReg1Value = L3GD20H::CTRL_REG_1_VAL;
+    uint8_t ctrlReg2Value = L3GD20H::CTRL_REG_2_VAL;
+    uint8_t ctrlReg3Value = L3GD20H::CTRL_REG_3_VAL;
+    uint8_t ctrlReg4Value = L3GD20H::CTRL_REG_4_VAL;
+    uint8_t ctrlReg5Value = L3GD20H::CTRL_REG_5_VAL;
+
+    uint8_t commandBuffer[L3GD20H::READ_LEN + 1];
+
+    // Set default value
+    float sensitivity = L3GD20H::SENSITIVITY_00;
+
+#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
+    PeriodicOperationDivider* debugDivider = nullptr;
+#endif
+};
+
+
+
+#endif /* MISSION_DEVICES_GYROL3GD20HANDLER_H_ */

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp

@@ -0,0 +1,520 @@
+#include "MgmLIS3MDLHandler.h"
+
+#include "fsfw/datapool/PoolReadGuard.h"
+#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#endif
+
+#include <cmath>
+
+MgmLIS3MDLHandler::MgmLIS3MDLHandler(object_id_t objectId, object_id_t deviceCommunication,
+        CookieIF* comCookie, uint32_t transitionDelay):
+        DeviceHandlerBase(objectId, deviceCommunication, comCookie),
+        dataset(this), transitionDelay(transitionDelay) {
+#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
+    debugDivider = new PeriodicOperationDivider(3);
+#endif
+    // Set to default values right away
+    registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
+    registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT;
+    registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT;
+    registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT;
+    registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
+
+}
+
+MgmLIS3MDLHandler::~MgmLIS3MDLHandler() {
+}
+
+
+void MgmLIS3MDLHandler::doStartUp() {
+    switch (internalState) {
+    case(InternalState::STATE_NONE): {
+        internalState = InternalState::STATE_FIRST_CONTACT;
+        break;
+    }
+    case(InternalState::STATE_FIRST_CONTACT): {
+        /* Will be set by checking device ID (WHO AM I register) */
+        if(commandExecuted) {
+            commandExecuted = false;
+            internalState = InternalState::STATE_SETUP;
+        }
+        break;
+    }
+    case(InternalState::STATE_SETUP): {
+        internalState = InternalState::STATE_CHECK_REGISTERS;
+        break;
+    }
+    case(InternalState::STATE_CHECK_REGISTERS): {
+        /* Set up cached registers which will be used to configure the MGM. */
+        if(commandExecuted) {
+            commandExecuted = false;
+            if(goToNormalMode) {
+                setMode(MODE_NORMAL);
+            }
+            else {
+                setMode(_MODE_TO_ON);
+            }
+        }
+        break;
+    }
+    default:
+        break;
+    }
+
+}
+
+void MgmLIS3MDLHandler::doShutDown() {
+    setMode(_MODE_POWER_DOWN);
+}
+
+ReturnValue_t MgmLIS3MDLHandler::buildTransitionDeviceCommand(
+        DeviceCommandId_t *id) {
+    switch (internalState) {
+    case(InternalState::STATE_NONE):
+    case(InternalState::STATE_NORMAL): {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(InternalState::STATE_FIRST_CONTACT): {
+        *id = MGMLIS3MDL::IDENTIFY_DEVICE;
+        break;
+    }
+    case(InternalState::STATE_SETUP): {
+        *id = MGMLIS3MDL::SETUP_MGM;
+        break;
+    }
+    case(InternalState::STATE_CHECK_REGISTERS): {
+        *id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+        break;
+    }
+    default: {
+        /* might be a configuration error. */
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "GyroHandler::buildTransitionDeviceCommand: Unknown internal state!" <<
+                std::endl;
+#else
+        sif::printWarning("GyroHandler::buildTransitionDeviceCommand: Unknown internal state!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    }
+    return buildCommandFromCommand(*id, NULL, 0);
+}
+
+uint8_t MgmLIS3MDLHandler::readCommand(uint8_t command, bool continuousCom) {
+    command |= (1 << MGMLIS3MDL::RW_BIT);
+    if (continuousCom == true) {
+        command |= (1 << MGMLIS3MDL::MS_BIT);
+    }
+    return command;
+}
+
+uint8_t MgmLIS3MDLHandler::writeCommand(uint8_t command, bool continuousCom) {
+    command &= ~(1 << MGMLIS3MDL::RW_BIT);
+    if (continuousCom == true) {
+        command |= (1 << MGMLIS3MDL::MS_BIT);
+    }
+    return command;
+}
+
+void MgmLIS3MDLHandler::setupMgm() {
+
+    registers[0] = MGMLIS3MDL::CTRL_REG1_DEFAULT;
+    registers[1] = MGMLIS3MDL::CTRL_REG2_DEFAULT;
+    registers[2] = MGMLIS3MDL::CTRL_REG3_DEFAULT;
+    registers[3] = MGMLIS3MDL::CTRL_REG4_DEFAULT;
+    registers[4] = MGMLIS3MDL::CTRL_REG5_DEFAULT;
+
+    prepareCtrlRegisterWrite();
+}
+
+ReturnValue_t MgmLIS3MDLHandler::buildNormalDeviceCommand(
+        DeviceCommandId_t *id) {
+    // Data/config register will be read in an alternating manner.
+    if(communicationStep == CommunicationStep::DATA) {
+        *id = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+        communicationStep = CommunicationStep::TEMPERATURE;
+        return buildCommandFromCommand(*id, NULL, 0);
+    }
+    else {
+        *id = MGMLIS3MDL::READ_TEMPERATURE;
+        communicationStep = CommunicationStep::DATA;
+        return buildCommandFromCommand(*id, NULL, 0);
+    }
+
+}
+
+ReturnValue_t MgmLIS3MDLHandler::buildCommandFromCommand(
+        DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+        size_t commandDataLen) {
+    switch(deviceCommand) {
+    case(MGMLIS3MDL::READ_CONFIG_AND_DATA): {
+        std::memset(commandBuffer, 0, sizeof(commandBuffer));
+        commandBuffer[0] = readCommand(MGMLIS3MDL::CTRL_REG1, true);
+
+        rawPacket = commandBuffer;
+        rawPacketLen = MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1;
+        return RETURN_OK;
+    }
+    case(MGMLIS3MDL::READ_TEMPERATURE): {
+        std::memset(commandBuffer, 0, 3);
+        commandBuffer[0] = readCommand(MGMLIS3MDL::TEMP_LOWBYTE, true);
+
+        rawPacket = commandBuffer;
+        rawPacketLen = 3;
+        return RETURN_OK;
+    }
+    case(MGMLIS3MDL::IDENTIFY_DEVICE): {
+        return identifyDevice();
+    }
+    case(MGMLIS3MDL::TEMP_SENSOR_ENABLE): {
+        return enableTemperatureSensor(commandData, commandDataLen);
+    }
+    case(MGMLIS3MDL::SETUP_MGM): {
+        setupMgm();
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+    case(MGMLIS3MDL::ACCURACY_OP_MODE_SET): {
+        return setOperatingMode(commandData, commandDataLen);
+    }
+    default:
+        return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+    }
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t MgmLIS3MDLHandler::identifyDevice() {
+    uint32_t size = 2;
+    commandBuffer[0] = readCommand(MGMLIS3MDL::IDENTIFY_DEVICE_REG_ADDR);
+    commandBuffer[1] = 0x00;
+
+    rawPacket = commandBuffer;
+    rawPacketLen = size;
+
+    return RETURN_OK;
+}
+
+ReturnValue_t MgmLIS3MDLHandler::scanForReply(const uint8_t *start,
+        size_t len, DeviceCommandId_t *foundId, size_t *foundLen) {
+    *foundLen = len;
+    if (len == MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1) {
+        *foundLen = len;
+        *foundId = MGMLIS3MDL::READ_CONFIG_AND_DATA;
+        // Check validity by checking config registers
+        if (start[1] != registers[0] or start[2] != registers[1] or
+                start[3] != registers[2] or start[4] != registers[3] or
+                start[5] != registers[4]) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "MGMHandlerLIS3MDL::scanForReply: Invalid registers!" << std::endl;
+#else
+            sif::printWarning("MGMHandlerLIS3MDL::scanForReply: Invalid registers!\n");
+#endif
+#endif
+            return DeviceHandlerIF::INVALID_DATA;
+        }
+        if(mode == _MODE_START_UP) {
+            commandExecuted = true;
+        }
+
+    }
+    else if(len == MGMLIS3MDL::TEMPERATURE_REPLY_LEN) {
+        *foundLen = len;
+        *foundId = MGMLIS3MDL::READ_TEMPERATURE;
+    }
+    else if (len == MGMLIS3MDL::SETUP_REPLY_LEN) {
+        *foundLen = len;
+        *foundId = MGMLIS3MDL::SETUP_MGM;
+    }
+    else if (len == SINGLE_COMMAND_ANSWER_LEN) {
+        *foundLen = len;
+        *foundId = getPendingCommand();
+        if(*foundId == MGMLIS3MDL::IDENTIFY_DEVICE) {
+            if(start[1] != MGMLIS3MDL::DEVICE_ID) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+                sif::warning << "MGMHandlerLIS3MDL::scanForReply: "
+                        "Device identification failed!" << std::endl;
+#else
+                sif::printWarning("MGMHandlerLIS3MDL::scanForReply: "
+                        "Device identification failed!\n");
+#endif
+#endif
+                return DeviceHandlerIF::INVALID_DATA;
+            }
+
+            if(mode == _MODE_START_UP) {
+                commandExecuted = true;
+            }
+        }
+    }
+    else {
+        return DeviceHandlerIF::INVALID_DATA;
+    }
+
+    /* Data with SPI Interface always has this answer */
+    if (start[0] == 0b11111111) {
+        return RETURN_OK;
+    }
+    else {
+        return DeviceHandlerIF::INVALID_DATA;
+    }
+
+}
+ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id,
+        const uint8_t *packet) {
+
+    switch (id) {
+    case MGMLIS3MDL::IDENTIFY_DEVICE: {
+        break;
+    }
+    case MGMLIS3MDL::SETUP_MGM: {
+        break;
+    }
+    case MGMLIS3MDL::READ_CONFIG_AND_DATA: {
+        // TODO: Store configuration in new local datasets.
+        float sensitivityFactor = getSensitivityFactor(getSensitivity(registers[2]));
+
+        int16_t mgmMeasurementRawX = packet[MGMLIS3MDL::X_HIGHBYTE_IDX] << 8
+                | packet[MGMLIS3MDL::X_LOWBYTE_IDX] ;
+        int16_t mgmMeasurementRawY = packet[MGMLIS3MDL::Y_HIGHBYTE_IDX] << 8
+                | packet[MGMLIS3MDL::Y_LOWBYTE_IDX] ;
+        int16_t mgmMeasurementRawZ = packet[MGMLIS3MDL::Z_HIGHBYTE_IDX] << 8
+                | packet[MGMLIS3MDL::Z_LOWBYTE_IDX] ;
+
+        /* Target value in microtesla */
+        float mgmX = static_cast<float>(mgmMeasurementRawX) * sensitivityFactor
+                *  MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+        float mgmY = static_cast<float>(mgmMeasurementRawY) * sensitivityFactor
+                *  MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+        float mgmZ = static_cast<float>(mgmMeasurementRawZ) * sensitivityFactor
+                *  MGMLIS3MDL::GAUSS_TO_MICROTESLA_FACTOR;
+
+#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
+        if(debugDivider->checkAndIncrement()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::info << "MGMHandlerLIS3: Magnetic field strength in"
+                    " microtesla:" << std::endl;
+            sif::info << "X: " << mgmX << " uT" << std::endl;
+            sif::info << "Y: " << mgmY << " uT" << std::endl;
+            sif::info << "Z: " << mgmZ << " uT" << std::endl;
+#else
+            sif::printInfo("MGMHandlerLIS3: Magnetic field strength in microtesla:\n");
+            sif::printInfo("X: %f uT\n", mgmX);
+            sif::printInfo("Y: %f uT\n", mgmY);
+            sif::printInfo("Z: %f uT\n", mgmZ);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 0 */
+        }
+#endif /* OBSW_VERBOSE_LEVEL >= 1 */
+        PoolReadGuard readHelper(&dataset);
+        if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+            if(std::abs(mgmX) < absLimitX) {
+                dataset.fieldStrengthX = mgmX;
+                dataset.fieldStrengthX.setValid(true);
+            }
+            else {
+                dataset.fieldStrengthX.setValid(false);
+            }
+
+            if(std::abs(mgmY) < absLimitY) {
+                dataset.fieldStrengthY = mgmY;
+                dataset.fieldStrengthY.setValid(true);
+            }
+            else {
+                dataset.fieldStrengthY.setValid(false);
+            }
+
+            if(std::abs(mgmZ) < absLimitZ) {
+                dataset.fieldStrengthZ = mgmZ;
+                dataset.fieldStrengthZ.setValid(true);
+            }
+            else {
+                dataset.fieldStrengthZ.setValid(false);
+            }
+        }
+        break;
+    }
+
+    case MGMLIS3MDL::READ_TEMPERATURE: {
+        int16_t tempValueRaw = packet[2] << 8 | packet[1];
+        float tempValue = 25.0 + ((static_cast<float>(tempValueRaw)) / 8.0);
+    #if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
+        if(debugDivider->check()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::info << "MGMHandlerLIS3: Temperature: " << tempValue << " C" <<
+                    std::endl;
+#else
+            sif::printInfo("MGMHandlerLIS3: Temperature: %f C\n");
+#endif
+        }
+#endif
+        ReturnValue_t result = dataset.read();
+        if(result == HasReturnvaluesIF::RETURN_OK) {
+            dataset.temperature = tempValue;
+            dataset.commit();
+        }
+        break;
+    }
+
+    default: {
+        return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
+    }
+
+    }
+    return RETURN_OK;
+}
+
+MGMLIS3MDL::Sensitivies MgmLIS3MDLHandler::getSensitivity(uint8_t ctrlRegister2) {
+    bool fs0Set = ctrlRegister2 & (1 << MGMLIS3MDL::FSO);  // Checks if FS0 bit is set
+    bool fs1Set = ctrlRegister2 & (1 << MGMLIS3MDL::FS1);  // Checks if FS1 bit is set
+
+    if (fs0Set && fs1Set)
+        return MGMLIS3MDL::Sensitivies::GAUSS_16;
+    else if (!fs0Set && fs1Set)
+        return MGMLIS3MDL::Sensitivies::GAUSS_12;
+    else if (fs0Set && !fs1Set)
+        return MGMLIS3MDL::Sensitivies::GAUSS_8;
+    else
+        return MGMLIS3MDL::Sensitivies::GAUSS_4;
+}
+
+float MgmLIS3MDLHandler::getSensitivityFactor(MGMLIS3MDL::Sensitivies sens) {
+    switch(sens) {
+    case(MGMLIS3MDL::GAUSS_4): {
+        return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS;
+    }
+    case(MGMLIS3MDL::GAUSS_8): {
+        return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_8_SENS;
+    }
+    case(MGMLIS3MDL::GAUSS_12): {
+        return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_12_SENS;
+    }
+    case(MGMLIS3MDL::GAUSS_16): {
+        return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_16_SENS;
+    }
+    default: {
+        // Should never happen
+        return MGMLIS3MDL::FIELD_LSB_PER_GAUSS_4_SENS;
+    }
+    }
+}
+
+
+ReturnValue_t MgmLIS3MDLHandler::enableTemperatureSensor(
+        const uint8_t *commandData, size_t commandDataLen) {
+    triggerEvent(CHANGE_OF_SETUP_PARAMETER);
+    uint32_t size = 2;
+    commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1);
+    if (commandDataLen > 1) {
+        return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
+    }
+    switch (*commandData) {
+    case (MGMLIS3MDL::ON): {
+        commandBuffer[1] = registers[0] | (1 << 7);
+        break;
+    }
+    case (MGMLIS3MDL::OFF): {
+        commandBuffer[1] = registers[0] & ~(1 << 7);
+        break;
+    }
+    default:
+        return INVALID_COMMAND_PARAMETER;
+    }
+    registers[0] = commandBuffer[1];
+
+    rawPacket = commandBuffer;
+    rawPacketLen = size;
+
+    return RETURN_OK;
+}
+
+ReturnValue_t MgmLIS3MDLHandler::setOperatingMode(const uint8_t *commandData,
+        size_t commandDataLen) {
+    triggerEvent(CHANGE_OF_SETUP_PARAMETER);
+    if (commandDataLen != 1) {
+        return INVALID_NUMBER_OR_LENGTH_OF_PARAMETERS;
+    }
+
+    switch (commandData[0]) {
+    case MGMLIS3MDL::LOW:
+        registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) & (~(1 << MGMLIS3MDL::OM0));
+        registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) & (~(1 << MGMLIS3MDL::OMZ0));
+        break;
+    case MGMLIS3MDL::MEDIUM:
+        registers[0] = (registers[0] & (~(1 << MGMLIS3MDL::OM1))) | (1 << MGMLIS3MDL::OM0);
+        registers[3] = (registers[3] & (~(1 << MGMLIS3MDL::OMZ1))) | (1 << MGMLIS3MDL::OMZ0);
+        break;
+
+    case MGMLIS3MDL::HIGH:
+        registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) & (~(1 << MGMLIS3MDL::OM0));
+        registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) & (~(1 << MGMLIS3MDL::OMZ0));
+        break;
+
+    case MGMLIS3MDL::ULTRA:
+        registers[0] = (registers[0] | (1 << MGMLIS3MDL::OM1)) | (1 << MGMLIS3MDL::OM0);
+        registers[3] = (registers[3] | (1 << MGMLIS3MDL::OMZ1)) | (1 << MGMLIS3MDL::OMZ0);
+        break;
+    default:
+        break;
+    }
+
+    return prepareCtrlRegisterWrite();
+}
+
+void MgmLIS3MDLHandler::fillCommandAndReplyMap() {
+    insertInCommandAndReplyMap(MGMLIS3MDL::READ_CONFIG_AND_DATA, 1, &dataset);
+    insertInCommandAndReplyMap(MGMLIS3MDL::READ_TEMPERATURE, 1);
+    insertInCommandAndReplyMap(MGMLIS3MDL::SETUP_MGM, 1);
+    insertInCommandAndReplyMap(MGMLIS3MDL::IDENTIFY_DEVICE, 1);
+    insertInCommandAndReplyMap(MGMLIS3MDL::TEMP_SENSOR_ENABLE, 1);
+    insertInCommandAndReplyMap(MGMLIS3MDL::ACCURACY_OP_MODE_SET, 1);
+}
+
+void MgmLIS3MDLHandler::setToGoToNormalMode(bool enable) {
+    this->goToNormalMode = enable;
+}
+
+ReturnValue_t MgmLIS3MDLHandler::prepareCtrlRegisterWrite() {
+    commandBuffer[0] = writeCommand(MGMLIS3MDL::CTRL_REG1, true);
+
+    for (size_t i = 0; i < MGMLIS3MDL::NR_OF_CTRL_REGISTERS; i++) {
+        commandBuffer[i + 1] = registers[i];
+    }
+    rawPacket = commandBuffer;
+    rawPacketLen = MGMLIS3MDL::NR_OF_CTRL_REGISTERS + 1;
+
+    // We dont have to check if this is working because we just did i
+    return RETURN_OK;
+}
+
+void MgmLIS3MDLHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+
+}
+
+uint32_t MgmLIS3MDLHandler::getTransitionDelayMs(Mode_t from, Mode_t to) {
+    return transitionDelay;
+}
+
+void MgmLIS3MDLHandler::modeChanged(void) {
+    internalState = InternalState::STATE_NONE;
+}
+
+ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_X,
+            new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Y,
+            new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(MGMLIS3MDL::FIELD_STRENGTH_Z,
+            new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(MGMLIS3MDL::TEMPERATURE_CELCIUS,
+            new PoolEntry<float>({0.0}));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MgmLIS3MDLHandler::setAbsoluteLimits(float xLimit, float yLimit, float zLimit) {
+    this->absLimitX = xLimit;
+    this->absLimitY = yLimit;
+    this->absLimitZ = zLimit;
+}

hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h

@@ -0,0 +1,186 @@
+#ifndef MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
+#define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
+
+#include "fsfw/FSFW.h"
+#include "events/subsystemIdRanges.h"
+#include "devicedefinitions/MgmLIS3HandlerDefs.h"
+
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+
+class PeriodicOperationDivider;
+
+/**
+ * @brief   Device handler object for the LIS3MDL 3-axis magnetometer
+ *          by STMicroeletronics
+ * @details
+ * Datasheet can be found online by googling LIS3MDL.
+ * Flight manual:
+ * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/LIS3MDL_MGM
+ * @author  L. Loidold, R. Mueller
+ */
+class MgmLIS3MDLHandler: public DeviceHandlerBase {
+public:
+    enum class CommunicationStep {
+        DATA,
+        TEMPERATURE
+    };
+
+    static const uint8_t INTERFACE_ID = CLASS_ID::MGM_LIS3MDL;
+    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::MGM_LIS3MDL;
+    //Notifies a command to change the setup parameters
+    static const Event CHANGE_OF_SETUP_PARAMETER = MAKE_EVENT(0, severity::LOW);
+
+    MgmLIS3MDLHandler(uint32_t objectId, object_id_t deviceCommunication, CookieIF* comCookie,
+            uint32_t transitionDelay);
+    virtual ~MgmLIS3MDLHandler();
+
+    /**
+     * Set the absolute limit for the values on the axis in microtesla. The dataset values will
+     * be marked as invalid if that limit is exceeded
+     * @param xLimit
+     * @param yLimit
+     * @param zLimit
+     */
+    void setAbsoluteLimits(float xLimit, float yLimit, float zLimit);
+    void setToGoToNormalMode(bool enable);
+
+protected:
+
+    /** DeviceHandlerBase overrides */
+    void doShutDown() override;
+    void doStartUp() override;
+    void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
+    virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+    ReturnValue_t buildCommandFromCommand(
+            DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+            size_t commandDataLen) override;
+    ReturnValue_t buildTransitionDeviceCommand(
+            DeviceCommandId_t *id) override;
+    ReturnValue_t buildNormalDeviceCommand(
+            DeviceCommandId_t *id) override;
+    ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+            DeviceCommandId_t *foundId, size_t *foundLen) override;
+    /**
+     * This implementation is tailored towards space applications and will flag values larger
+     * than 100 microtesla on X,Y and 150 microtesla on Z as invalid
+     * @param id
+     * @param packet
+     * @return
+     */
+    virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+            const uint8_t *packet) override;
+    void fillCommandAndReplyMap() override;
+    void modeChanged(void) override;
+    ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+            LocalDataPoolManager &poolManager) override;
+
+private:
+    MGMLIS3MDL::MgmPrimaryDataset dataset;
+    //Length a single command SPI answer
+    static const uint8_t SINGLE_COMMAND_ANSWER_LEN = 2;
+
+    uint32_t transitionDelay;
+    // Single SPI command has 2 bytes, first for adress, second for content
+    size_t singleComandSize = 2;
+    // Has the size for all adresses of the lis3mdl + the continous write bit
+    uint8_t commandBuffer[MGMLIS3MDL::NR_OF_DATA_AND_CFG_REGISTERS + 1];
+
+    float absLimitX = 100;
+    float absLimitY = 100;
+    float absLimitZ = 150;
+
+    /**
+     * We want to save the registers we set, so we dont have to read the
+     * registers when we want to change something.
+     * --> everytime we change set a register we have to save it
+     */
+    uint8_t registers[MGMLIS3MDL::NR_OF_CTRL_REGISTERS];
+
+    uint8_t statusRegister = 0;
+    bool goToNormalMode = false;
+
+    enum class InternalState {
+        STATE_NONE,
+        STATE_FIRST_CONTACT,
+        STATE_SETUP,
+        STATE_CHECK_REGISTERS,
+        STATE_NORMAL
+    };
+
+    InternalState internalState = InternalState::STATE_NONE;
+    CommunicationStep communicationStep = CommunicationStep::DATA;
+    bool commandExecuted = false;
+
+    /*------------------------------------------------------------------------*/
+    /* Device specific commands and variables */
+    /*------------------------------------------------------------------------*/
+    /**
+     * Sets the read bit for the command
+     * @param single command to set the read-bit at
+     * @param boolean to select a continuous read bit, default = false
+     */
+    uint8_t readCommand(uint8_t command, bool continuousCom = false);
+
+    /**
+     * Sets the write bit for the command
+     * @param single command to set the write-bit at
+     * @param boolean to select a continuous write bit, default = false
+     */
+    uint8_t writeCommand(uint8_t command, bool continuousCom = false);
+
+    /**
+     * This Method gets the full scale for the measurement range
+     * e.g.: +- 4 gauss. See p.25 datasheet.
+     *  @return The ReturnValue does not contain the sign of the value
+     */
+    MGMLIS3MDL::Sensitivies getSensitivity(uint8_t ctrlReg2);
+
+    /**
+     * The 16 bit value needs to be multiplied with a sensitivity factor
+     * which depends on the sensitivity configuration
+     *
+     * @param sens Configured sensitivity of the LIS3 device
+     * @return Multiplication factor to get the sensor value from raw data.
+     */
+    float getSensitivityFactor(MGMLIS3MDL::Sensitivies sens);
+
+    /**
+     * This Command detects the device ID
+     */
+    ReturnValue_t identifyDevice();
+
+    virtual void setupMgm();
+
+    /*------------------------------------------------------------------------*/
+    /* Non normal commands */
+    /*------------------------------------------------------------------------*/
+    /**
+     * Enables/Disables the integrated Temperaturesensor
+     * @param commandData On or Off
+     * @param length of the commandData: has to be 1
+     */
+    virtual ReturnValue_t enableTemperatureSensor(const uint8_t *commandData,
+            size_t commandDataLen);
+
+    /**
+     * Sets the accuracy of the measurement of the axis. The noise is changing.
+     * @param commandData LOW, MEDIUM, HIGH, ULTRA
+     * @param length of the command, has to be 1
+     */
+    virtual ReturnValue_t setOperatingMode(const uint8_t *commandData,
+            size_t commandDataLen);
+
+    /**
+     * We always update all registers together, so this method updates
+     * the rawpacket and rawpacketLen, so we just manipulate the local
+     * saved register
+     *
+     */
+    ReturnValue_t prepareCtrlRegisterWrite();
+
+#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
+    PeriodicOperationDivider* debugDivider;
+#endif
+};
+
+#endif /* MISSION_DEVICES_MGMLIS3MDLHANDLER_H_ */

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp

@@ -0,0 +1,376 @@
+#include "MgmRM3100Handler.h"
+
+#include "fsfw/datapool/PoolReadGuard.h"
+#include "fsfw/globalfunctions/bitutility.h"
+#include "fsfw/devicehandlers/DeviceHandlerMessage.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+
+MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId,
+        object_id_t deviceCommunication, CookieIF* comCookie, uint32_t transitionDelay):
+        DeviceHandlerBase(objectId, deviceCommunication, comCookie),
+        primaryDataset(this), transitionDelay(transitionDelay) {
+#if FSFW_HAL_RM3100_MGM_DEBUG == 1
+    debugDivider = new PeriodicOperationDivider(3);
+#endif
+}
+
+MgmRM3100Handler::~MgmRM3100Handler() {}
+
+void MgmRM3100Handler::doStartUp() {
+    switch(internalState) {
+    case(InternalState::NONE): {
+        internalState = InternalState::CONFIGURE_CMM;
+        break;
+    }
+    case(InternalState::CONFIGURE_CMM): {
+        internalState = InternalState::READ_CMM;
+        break;
+    }
+    case(InternalState::READ_CMM): {
+        if(commandExecuted) {
+            internalState = InternalState::STATE_CONFIGURE_TMRC;
+        }
+        break;
+    }
+    case(InternalState::STATE_CONFIGURE_TMRC): {
+        if(commandExecuted) {
+            internalState = InternalState::STATE_READ_TMRC;
+        }
+        break;
+    }
+    case(InternalState::STATE_READ_TMRC): {
+        if(commandExecuted) {
+            internalState = InternalState::NORMAL;
+            if(goToNormalModeAtStartup) {
+                setMode(MODE_NORMAL);
+            }
+            else {
+                setMode(_MODE_TO_ON);
+            }
+        }
+        break;
+    }
+    default: {
+        break;
+    }
+    }
+}
+
+void MgmRM3100Handler::doShutDown() {
+    setMode(_MODE_POWER_DOWN);
+}
+
+ReturnValue_t MgmRM3100Handler::buildTransitionDeviceCommand(
+        DeviceCommandId_t *id) {
+    size_t commandLen = 0;
+    switch(internalState) {
+    case(InternalState::NONE):
+    case(InternalState::NORMAL): {
+        return NOTHING_TO_SEND;
+    }
+    case(InternalState::CONFIGURE_CMM): {
+        *id = RM3100::CONFIGURE_CMM;
+        break;
+    }
+    case(InternalState::READ_CMM): {
+        *id = RM3100::READ_CMM;
+        break;
+    }
+    case(InternalState::STATE_CONFIGURE_TMRC): {
+        commandBuffer[0] = RM3100::TMRC_DEFAULT_VALUE;
+        commandLen = 1;
+        *id = RM3100::CONFIGURE_TMRC;
+        break;
+    }
+    case(InternalState::STATE_READ_TMRC): {
+        *id = RM3100::READ_TMRC;
+        break;
+    }
+    default:
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        // Might be a configuration error
+        sif::warning << "MgmRM3100Handler::buildTransitionDeviceCommand: "
+                "Unknown internal state" << std::endl;
+#else
+        sif::printWarning("MgmRM3100Handler::buildTransitionDeviceCommand: "
+                "Unknown internal state\n");
+#endif
+#endif
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    return buildCommandFromCommand(*id, commandBuffer, commandLen);
+}
+
+ReturnValue_t MgmRM3100Handler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+        const uint8_t *commandData, size_t commandDataLen) {
+    switch(deviceCommand) {
+    case(RM3100::CONFIGURE_CMM): {
+        commandBuffer[0] = RM3100::CMM_REGISTER;
+        commandBuffer[1] = RM3100::CMM_VALUE;
+        rawPacket = commandBuffer;
+        rawPacketLen = 2;
+        break;
+    }
+    case(RM3100::READ_CMM): {
+        commandBuffer[0] = RM3100::CMM_REGISTER | RM3100::READ_MASK;
+        commandBuffer[1] = 0;
+        rawPacket = commandBuffer;
+        rawPacketLen = 2;
+        break;
+    }
+    case(RM3100::CONFIGURE_TMRC): {
+        return handleTmrcConfigCommand(deviceCommand, commandData, commandDataLen);
+    }
+    case(RM3100::READ_TMRC): {
+        commandBuffer[0] = RM3100::TMRC_REGISTER | RM3100::READ_MASK;
+        commandBuffer[1] = 0;
+        rawPacket = commandBuffer;
+        rawPacketLen = 2;
+        break;
+    }
+    case(RM3100::CONFIGURE_CYCLE_COUNT): {
+        return handleCycleCountConfigCommand(deviceCommand, commandData, commandDataLen);
+    }
+    case(RM3100::READ_CYCLE_COUNT): {
+        commandBuffer[0] = RM3100::CYCLE_COUNT_START_REGISTER | RM3100::READ_MASK;
+        std::memset(commandBuffer + 1, 0, 6);
+        rawPacket = commandBuffer;
+        rawPacketLen = 7;
+        break;
+    }
+    case(RM3100::READ_DATA): {
+        commandBuffer[0] = RM3100::MEASUREMENT_REG_START | RM3100::READ_MASK;
+        std::memset(commandBuffer + 1, 0,  9);
+        rawPacketLen = 10;
+        break;
+    }
+    default:
+        return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+    }
+    return RETURN_OK;
+}
+
+ReturnValue_t MgmRM3100Handler::buildNormalDeviceCommand(
+        DeviceCommandId_t *id) {
+    *id = RM3100::READ_DATA;
+    return buildCommandFromCommand(*id, nullptr, 0);
+}
+
+ReturnValue_t MgmRM3100Handler::scanForReply(const uint8_t *start,
+        size_t len, DeviceCommandId_t *foundId,
+        size_t *foundLen) {
+
+    // For SPI, ID will always be the one of the last sent command
+    *foundId = this->getPendingCommand();
+    *foundLen = len;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MgmRM3100Handler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    switch(id) {
+    case(RM3100::CONFIGURE_CMM):
+    case(RM3100::CONFIGURE_CYCLE_COUNT):
+    case(RM3100::CONFIGURE_TMRC): {
+        // We can only check whether write was successful with read operation
+        if(mode == _MODE_START_UP) {
+            commandExecuted = true;
+        }
+        break;
+    }
+    case(RM3100::READ_CMM): {
+        uint8_t cmmValue = packet[1];
+        // We clear the seventh bit in any case
+        // because this one is zero sometimes for some reason
+        bitutil::bitClear(&cmmValue, 6);
+        if(cmmValue == cmmRegValue and internalState == InternalState::READ_CMM) {
+            commandExecuted = true;
+        }
+        else {
+            // Attempt reconfiguration
+            internalState = InternalState::CONFIGURE_CMM;
+            return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+        }
+        break;
+    }
+    case(RM3100::READ_TMRC): {
+        if(packet[1] == tmrcRegValue) {
+            commandExecuted = true;
+            // Reading TMRC was commanded. Trigger event to inform ground
+            if(mode != _MODE_START_UP) {
+                triggerEvent(tmrcSet, tmrcRegValue, 0);
+            }
+        }
+        else {
+            // Attempt reconfiguration
+            internalState = InternalState::STATE_CONFIGURE_TMRC;
+            return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+        }
+        break;
+    }
+    case(RM3100::READ_CYCLE_COUNT): {
+        uint16_t cycleCountX = packet[1] << 8 | packet[2];
+        uint16_t cycleCountY = packet[3] << 8 | packet[4];
+        uint16_t cycleCountZ = packet[5] << 8 | packet[6];
+        if(cycleCountX != cycleCountRegValueX or cycleCountY != cycleCountRegValueY or
+                cycleCountZ != cycleCountRegValueZ) {
+            return DeviceHandlerIF::DEVICE_REPLY_INVALID;
+        }
+        // Reading TMRC was commanded. Trigger event to inform ground
+        if(mode != _MODE_START_UP) {
+            uint32_t eventParam1 = (cycleCountX << 16) | cycleCountY;
+            triggerEvent(cycleCountersSet, eventParam1, cycleCountZ);
+        }
+        break;
+    }
+    case(RM3100::READ_DATA): {
+        result = handleDataReadout(packet);
+        break;
+    }
+    default:
+        return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
+    }
+
+    return result;
+}
+
+ReturnValue_t MgmRM3100Handler::handleCycleCountConfigCommand(DeviceCommandId_t deviceCommand,
+        const uint8_t *commandData, size_t commandDataLen) {
+    if(commandData == nullptr) {
+        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+    }
+
+    // Set cycle count
+    if(commandDataLen == 2) {
+        handleCycleCommand(true, commandData, commandDataLen);
+    }
+    else if(commandDataLen == 6) {
+        handleCycleCommand(false, commandData, commandDataLen);
+    }
+    else {
+        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+    }
+
+    commandBuffer[0] = RM3100::CYCLE_COUNT_VALUE;
+    std::memcpy(commandBuffer + 1, &cycleCountRegValueX, 2);
+    std::memcpy(commandBuffer + 3, &cycleCountRegValueY, 2);
+    std::memcpy(commandBuffer + 5, &cycleCountRegValueZ, 2);
+    rawPacketLen = 7;
+    rawPacket = commandBuffer;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MgmRM3100Handler::handleCycleCommand(bool oneCycleValue,
+        const uint8_t *commandData, size_t commandDataLen) {
+    RM3100::CycleCountCommand command(oneCycleValue);
+    ReturnValue_t result = command.deSerialize(&commandData, &commandDataLen,
+            SerializeIF::Endianness::BIG);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    // Data sheet p.30 "while noise limits the useful upper range to ~400 cycle counts."
+    if(command.cycleCountX > 450 ) {
+        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+    }
+
+    if(not oneCycleValue and (command.cycleCountY > 450 or command.cycleCountZ > 450)) {
+        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+    }
+
+    cycleCountRegValueX = command.cycleCountX;
+    cycleCountRegValueY = command.cycleCountY;
+    cycleCountRegValueZ = command.cycleCountZ;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t MgmRM3100Handler::handleTmrcConfigCommand(DeviceCommandId_t deviceCommand,
+        const uint8_t *commandData, size_t commandDataLen) {
+    if(commandData == nullptr or commandDataLen != 1) {
+        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
+    }
+
+    commandBuffer[0] = RM3100::TMRC_REGISTER;
+    commandBuffer[1] = commandData[0];
+    tmrcRegValue = commandData[0];
+    rawPacketLen = 2;
+    rawPacket = commandBuffer;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void MgmRM3100Handler::fillCommandAndReplyMap() {
+    insertInCommandAndReplyMap(RM3100::CONFIGURE_CMM, 3);
+    insertInCommandAndReplyMap(RM3100::READ_CMM, 3);
+
+    insertInCommandAndReplyMap(RM3100::CONFIGURE_TMRC, 3);
+    insertInCommandAndReplyMap(RM3100::READ_TMRC, 3);
+
+    insertInCommandAndReplyMap(RM3100::CONFIGURE_CYCLE_COUNT, 3);
+    insertInCommandAndReplyMap(RM3100::READ_CYCLE_COUNT, 3);
+
+    insertInCommandAndReplyMap(RM3100::READ_DATA, 3, &primaryDataset);
+}
+
+void MgmRM3100Handler::modeChanged(void) {
+    internalState = InternalState::NONE;
+}
+
+ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_X, new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Y, new PoolEntry<float>({0.0}));
+    localDataPoolMap.emplace(RM3100::FIELD_STRENGTH_Z, new PoolEntry<float>({0.0}));
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t MgmRM3100Handler::getTransitionDelayMs(Mode_t from, Mode_t to) {
+    return this->transitionDelay;
+}
+
+void MgmRM3100Handler::setToGoToNormalMode(bool enable) {
+    goToNormalModeAtStartup = enable;
+}
+
+ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
+    // Analyze data here. The sensor generates 24 bit signed values so we need to do some bitshift
+    // trickery here to calculate the raw values first
+    int32_t fieldStrengthRawX = ((packet[1] << 24) | (packet[2] << 16) | (packet[3] << 8)) >> 8;
+    int32_t fieldStrengthRawY = ((packet[4] << 24) | (packet[5] << 16) | (packet[6] << 8)) >> 8;
+    int32_t fieldStrengthRawZ  = ((packet[7] << 24) | (packet[8] << 16) | (packet[3] << 8)) >> 8;
+
+    // Now scale to physical value in microtesla
+    float fieldStrengthX = fieldStrengthRawX * scaleFactorX;
+    float fieldStrengthY = fieldStrengthRawY * scaleFactorX;
+    float fieldStrengthZ = fieldStrengthRawZ * scaleFactorX;
+
+#if FSFW_HAL_RM3100_MGM_DEBUG == 1
+    if(debugDivider->checkAndIncrement()) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::info << "MgmRM3100Handler: Magnetic field strength in"
+                " microtesla:" << std::endl;
+        sif::info << "X: " << fieldStrengthX << " uT" << std::endl;
+        sif::info << "Y: " << fieldStrengthY << " uT" << std::endl;
+        sif::info << "Z: " << fieldStrengthZ << " uT" << std::endl;
+#else
+        sif::printInfo("MgmRM3100Handler: Magnetic field strength in microtesla:\n");
+        sif::printInfo("X: %f uT\n", fieldStrengthX);
+        sif::printInfo("Y: %f uT\n", fieldStrengthY);
+        sif::printInfo("Z: %f uT\n", fieldStrengthZ);
+#endif
+    }
+#endif
+
+    // TODO: Sanity check on values?
+    PoolReadGuard readGuard(&primaryDataset);
+    if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+        primaryDataset.fieldStrengthX = fieldStrengthX;
+        primaryDataset.fieldStrengthY = fieldStrengthY;
+        primaryDataset.fieldStrengthZ = fieldStrengthZ;
+        primaryDataset.setValidity(true, true);
+    }
+    return RETURN_OK;
+}

hal/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h

@@ -0,0 +1,110 @@
+#ifndef MISSION_DEVICES_MGMRM3100HANDLER_H_
+#define MISSION_DEVICES_MGMRM3100HANDLER_H_
+
+#include "fsfw/FSFW.h"
+#include "devicedefinitions/MgmRM3100HandlerDefs.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+
+#if FSFW_HAL_RM3100_MGM_DEBUG == 1
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#endif
+
+/**
+ * @brief 	Device Handler for the RM3100 geomagnetic magnetometer sensor
+ *          (https://www.pnicorp.com/rm3100/)
+ * @details
+ * Flight manual:
+ * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/RM3100_MGM
+ */
+class MgmRM3100Handler: public DeviceHandlerBase {
+public:
+	static const uint8_t INTERFACE_ID = CLASS_ID::MGM_RM3100;
+
+	//! [EXPORT] : [COMMENT] P1: TMRC value which was set, P2: 0
+	static constexpr Event tmrcSet = event::makeEvent(SUBSYSTEM_ID::MGM_RM3100,
+			0x00, severity::INFO);
+
+	//! [EXPORT] : [COMMENT] Cycle counter set. P1: First two bytes new Cycle Count X
+	//! P1: Second two bytes new Cycle Count Y
+	//! P2: New cycle count Z
+	static constexpr Event cycleCountersSet = event::makeEvent(
+			SUBSYSTEM_ID::MGM_RM3100, 0x01, severity::INFO);
+
+	MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommunication,
+	        CookieIF* comCookie, uint32_t transitionDelay);
+	virtual ~MgmRM3100Handler();
+
+	/**
+	 * Configure device handler to go to normal mode after startup immediately
+	 * @param enable
+	 */
+	void setToGoToNormalMode(bool enable);
+
+protected:
+
+	/* DeviceHandlerBase overrides */
+	ReturnValue_t buildTransitionDeviceCommand(
+	        DeviceCommandId_t *id) override;
+	void doStartUp() override;
+	void doShutDown() override;
+	ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+	        const uint8_t *commandData, size_t commandDataLen) override;
+	ReturnValue_t scanForReply(const uint8_t *start, size_t len,
+			DeviceCommandId_t *foundId, size_t *foundLen) override;
+	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+
+	void fillCommandAndReplyMap() override;
+	void modeChanged(void) override;
+	virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
+	ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+			LocalDataPoolManager &poolManager) override;
+
+private:
+
+	enum class InternalState {
+	    NONE,
+		CONFIGURE_CMM,
+		READ_CMM,
+		// The cycle count states are propably not going to be used because
+		// the default cycle count will be used.
+		STATE_CONFIGURE_CYCLE_COUNT,
+		STATE_READ_CYCLE_COUNT,
+		STATE_CONFIGURE_TMRC,
+		STATE_READ_TMRC,
+		NORMAL
+	};
+	InternalState internalState = InternalState::NONE;
+	bool commandExecuted = false;
+	RM3100::Rm3100PrimaryDataset primaryDataset;
+
+	uint8_t commandBuffer[10];
+	uint8_t commandBufferLen = 0;
+
+	uint8_t cmmRegValue = RM3100::CMM_VALUE;
+	uint8_t tmrcRegValue = RM3100::TMRC_DEFAULT_VALUE;
+	uint16_t cycleCountRegValueX = RM3100::CYCLE_COUNT_VALUE;
+	uint16_t cycleCountRegValueY = RM3100::CYCLE_COUNT_VALUE;
+	uint16_t cycleCountRegValueZ = RM3100::CYCLE_COUNT_VALUE;
+	float scaleFactorX = 1.0 / RM3100::DEFAULT_GAIN;
+	float scaleFactorY = 1.0 / RM3100::DEFAULT_GAIN;
+	float scaleFactorZ = 1.0 / RM3100::DEFAULT_GAIN;
+
+	bool goToNormalModeAtStartup = false;
+	uint32_t transitionDelay;
+
+	ReturnValue_t handleCycleCountConfigCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t *commandData,size_t commandDataLen);
+	ReturnValue_t handleCycleCommand(bool oneCycleValue,
+			const uint8_t *commandData, size_t commandDataLen);
+
+	ReturnValue_t handleTmrcConfigCommand(DeviceCommandId_t deviceCommand,
+			const uint8_t *commandData,size_t commandDataLen);
+
+	ReturnValue_t handleDataReadout(const uint8_t* packet);
+#if FSFW_HAL_RM3100_MGM_DEBUG == 1
+	PeriodicOperationDivider* debugDivider;
+#endif
+};
+
+#endif /* MISSION_DEVICEHANDLING_MGMRM3100HANDLER_H_ */

hal/src/fsfw_hal/devicehandlers/devicedefinitions/GyroL3GD20Definitions.h

@@ -0,0 +1,143 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <cstdint>
+
+namespace L3GD20H {
+
+/* Actual size is 15 but we round up a bit */
+static constexpr size_t MAX_BUFFER_SIZE = 16;
+
+static constexpr uint8_t READ_MASK = 0b10000000;
+
+static constexpr uint8_t AUTO_INCREMENT_MASK = 0b01000000;
+
+static constexpr uint8_t WHO_AM_I_REG = 0b00001111;
+static constexpr uint8_t WHO_AM_I_VAL = 0b11010111;
+
+/*------------------------------------------------------------------------*/
+/* Control registers */
+/*------------------------------------------------------------------------*/
+static constexpr uint8_t CTRL_REG_1 = 0b00100000;
+static constexpr uint8_t CTRL_REG_2 = 0b00100001;
+static constexpr uint8_t CTRL_REG_3 = 0b00100010;
+static constexpr uint8_t CTRL_REG_4 = 0b00100011;
+static constexpr uint8_t CTRL_REG_5 = 0b00100100;
+
+/* Register 1 */
+static constexpr uint8_t SET_DR_1 = 1 << 7;
+static constexpr uint8_t SET_DR_0 = 1 << 6;
+static constexpr uint8_t SET_BW_1 = 1 << 5;
+static constexpr uint8_t SET_BW_0 = 1 << 4;
+static constexpr uint8_t SET_POWER_NORMAL_MODE = 1 << 3;
+static constexpr uint8_t SET_Z_ENABLE = 1 << 2;
+static constexpr uint8_t SET_X_ENABLE = 1 << 1;
+static constexpr uint8_t SET_Y_ENABLE = 1;
+
+static constexpr uint8_t CTRL_REG_1_VAL = SET_POWER_NORMAL_MODE | SET_Z_ENABLE |
+		SET_Y_ENABLE | SET_X_ENABLE;
+
+/* Register 2 */
+static constexpr uint8_t EXTERNAL_EDGE_ENB = 1 << 7;
+static constexpr uint8_t LEVEL_SENSITIVE_TRIGGER = 1 << 6;
+static constexpr uint8_t SET_HPM_1 = 1 << 5;
+static constexpr uint8_t SET_HPM_0 = 1 << 4;
+static constexpr uint8_t SET_HPCF_3 = 1 << 3;
+static constexpr uint8_t SET_HPCF_2 = 1 << 2;
+static constexpr uint8_t SET_HPCF_1 = 1 << 1;
+static constexpr uint8_t SET_HPCF_0 = 1;
+
+static constexpr uint8_t CTRL_REG_2_VAL = 0b00000000;
+
+/* Register 3 */
+static constexpr uint8_t CTRL_REG_3_VAL = 0b00000000;
+
+/* Register 4 */
+static constexpr uint8_t SET_BNU = 1 << 7;
+static constexpr uint8_t SET_BLE = 1 << 6;
+static constexpr uint8_t SET_FS_1 = 1 << 5;
+static constexpr uint8_t SET_FS_0 = 1 << 4;
+static constexpr uint8_t SET_IMP_ENB = 1 << 3;
+static constexpr uint8_t SET_SELF_TEST_ENB_1 = 1 << 2;
+static constexpr uint8_t SET_SELF_TEST_ENB_0 = 1 << 1;
+static constexpr uint8_t SET_SPI_IF_SELECT = 1;
+
+/* Enable big endian data format */
+static constexpr uint8_t CTRL_REG_4_VAL = SET_BLE;
+
+/* Register 5 */
+static constexpr uint8_t SET_REBOOT_MEM = 1 << 7;
+static constexpr uint8_t SET_FIFO_ENB = 1 << 6;
+
+static constexpr uint8_t CTRL_REG_5_VAL = 0b00000000;
+
+/* Possible range values in degrees per second (DPS). */
+static constexpr uint16_t RANGE_DPS_00 = 245;
+static constexpr float SENSITIVITY_00 = 8.75 * 0.001;
+static constexpr uint16_t RANGE_DPS_01 = 500;
+static constexpr float SENSITIVITY_01 = 17.5 * 0.001;
+static constexpr uint16_t RANGE_DPS_11 = 2000;
+static constexpr float SENSITIVITY_11 = 70.0 * 0.001;
+
+static constexpr uint8_t READ_START = CTRL_REG_1;
+static constexpr size_t READ_LEN = 14;
+
+/* Indexing */
+static constexpr uint8_t REFERENCE_IDX = 6;
+static constexpr uint8_t TEMPERATURE_IDX = 7;
+static constexpr uint8_t STATUS_IDX = 8;
+static constexpr uint8_t OUT_X_H = 9;
+static constexpr uint8_t OUT_X_L = 10;
+static constexpr uint8_t OUT_Y_H = 11;
+static constexpr uint8_t OUT_Y_L = 12;
+static constexpr uint8_t OUT_Z_H = 13;
+static constexpr uint8_t OUT_Z_L = 14;
+
+/*------------------------------------------------------------------------*/
+/* Device Handler specific */
+/*------------------------------------------------------------------------*/
+static constexpr DeviceCommandId_t READ_REGS = 0;
+static constexpr DeviceCommandId_t CONFIGURE_CTRL_REGS = 1;
+static constexpr DeviceCommandId_t READ_CTRL_REGS = 2;
+
+static constexpr uint32_t GYRO_DATASET_ID = READ_REGS;
+
+enum GyroPoolIds: lp_id_t {
+    ANG_VELOC_X,
+	ANG_VELOC_Y,
+	ANG_VELOC_Z,
+	TEMPERATURE
+};
+
+}
+
+class GyroPrimaryDataset: public StaticLocalDataSet<5> {
+public:
+
+    /** Constructor  for data users like controllers */
+    GyroPrimaryDataset(object_id_t mgmId):
+        StaticLocalDataSet(sid_t(mgmId, L3GD20H::GYRO_DATASET_ID)) {
+        setAllVariablesReadOnly();
+    }
+
+    /* Angular velocities in degrees per second (DPS) */
+    lp_var_t<float> angVelocX = lp_var_t<float>(sid.objectId,
+            L3GD20H::ANG_VELOC_X, this);
+    lp_var_t<float> angVelocY = lp_var_t<float>(sid.objectId,
+            L3GD20H::ANG_VELOC_Y, this);
+    lp_var_t<float> angVelocZ = lp_var_t<float>(sid.objectId,
+            L3GD20H::ANG_VELOC_Z, this);
+    lp_var_t<float> temperature = lp_var_t<float>(sid.objectId,
+            L3GD20H::TEMPERATURE, this);
+private:
+
+    friend class GyroHandlerL3GD20H;
+    /** Constructor  for the data creator */
+    GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner):
+            StaticLocalDataSet(hkOwner, L3GD20H::GYRO_DATASET_ID) {}
+};
+
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_ */

hal/src/fsfw_hal/devicehandlers/devicedefinitions/MgmLIS3HandlerDefs.h

@@ -0,0 +1,178 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <cstdint>
+
+namespace MGMLIS3MDL {
+
+enum Set {
+    ON, OFF
+};
+enum OpMode {
+    LOW, MEDIUM, HIGH, ULTRA
+};
+
+enum Sensitivies: uint8_t {
+    GAUSS_4 = 4,
+    GAUSS_8 = 8,
+    GAUSS_12 = 12,
+    GAUSS_16 = 16
+};
+
+/* Actually 15, we just round up a bit */
+static constexpr size_t MAX_BUFFER_SIZE = 16;
+
+/* Field data register scaling */
+static constexpr uint8_t GAUSS_TO_MICROTESLA_FACTOR = 100;
+static constexpr float FIELD_LSB_PER_GAUSS_4_SENS = 1.0 / 6842.0;
+static constexpr float FIELD_LSB_PER_GAUSS_8_SENS = 1.0 / 3421.0;
+static constexpr float FIELD_LSB_PER_GAUSS_12_SENS = 1.0 / 2281.0;
+static constexpr float FIELD_LSB_PER_GAUSS_16_SENS = 1.0 / 1711.0;
+
+static const DeviceCommandId_t READ_CONFIG_AND_DATA = 0x00;
+static const DeviceCommandId_t SETUP_MGM = 0x01;
+static const DeviceCommandId_t READ_TEMPERATURE = 0x02;
+static const DeviceCommandId_t IDENTIFY_DEVICE = 0x03;
+static const DeviceCommandId_t TEMP_SENSOR_ENABLE = 0x04;
+static const DeviceCommandId_t ACCURACY_OP_MODE_SET = 0x05;
+
+/* Number of all control registers */
+static const uint8_t NR_OF_CTRL_REGISTERS = 5;
+/* Number of registers in the MGM */
+static const uint8_t NR_OF_REGISTERS = 19;
+/* Total number of adresses for all registers */
+static const uint8_t TOTAL_NR_OF_ADRESSES = 52;
+static const uint8_t NR_OF_DATA_AND_CFG_REGISTERS = 14;
+static const uint8_t TEMPERATURE_REPLY_LEN = 3;
+static const uint8_t SETUP_REPLY_LEN = 6;
+
+/*------------------------------------------------------------------------*/
+/* Register adresses */
+/*------------------------------------------------------------------------*/
+/* Register adress returns identifier of device with default 0b00111101 */
+static const uint8_t IDENTIFY_DEVICE_REG_ADDR = 0b00001111;
+static const uint8_t DEVICE_ID = 0b00111101;            // Identifier for Device
+
+/* Register adress to access register 1 */
+static const uint8_t CTRL_REG1 = 0b00100000;
+/* Register adress to access register 2 */
+static const uint8_t CTRL_REG2 = 0b00100001;
+/* Register adress to access register 3 */
+static const uint8_t CTRL_REG3 = 0b00100010;
+/* Register adress to access register 4 */
+static const uint8_t CTRL_REG4 = 0b00100011;
+/* Register adress to access register 5 */
+static const uint8_t CTRL_REG5 = 0b00100100;
+
+/* Register adress to access status register */
+static const uint8_t STATUS_REG_IDX = 8;
+static const uint8_t STATUS_REG = 0b00100111;
+
+/* Register adress to access low byte of x-axis */
+static const uint8_t X_LOWBYTE_IDX = 9;
+static const uint8_t X_LOWBYTE = 0b00101000;
+/* Register adress to access high byte of x-axis */
+static const uint8_t X_HIGHBYTE_IDX = 10;
+static const uint8_t X_HIGHBYTE = 0b00101001;
+/* Register adress to access low byte of y-axis */
+static const uint8_t Y_LOWBYTE_IDX = 11;
+static const uint8_t Y_LOWBYTE = 0b00101010;
+/* Register adress to access high byte of y-axis */
+static const uint8_t Y_HIGHBYTE_IDX = 12;
+static const uint8_t Y_HIGHBYTE = 0b00101011;
+/* Register adress to access low byte of z-axis */
+static const uint8_t Z_LOWBYTE_IDX = 13;
+static const uint8_t Z_LOWBYTE = 0b00101100;
+/* Register adress to access high byte of z-axis */
+static const uint8_t Z_HIGHBYTE_IDX = 14;
+static const uint8_t Z_HIGHBYTE = 0b00101101;
+
+/* Register adress to access low byte of temperature sensor */
+static const uint8_t TEMP_LOWBYTE = 0b00101110;
+/* Register adress to access high byte of temperature sensor */
+static const uint8_t TEMP_HIGHBYTE = 0b00101111;
+
+/*------------------------------------------------------------------------*/
+/* Initialize Setup Register set bits                                     */
+/*------------------------------------------------------------------------*/
+/* General transfer bits */
+// Read=1 / Write=0 Bit
+static const uint8_t RW_BIT = 7;
+// Continous Read/Write Bit, increment adress
+static const uint8_t MS_BIT = 6;
+
+/* CTRL_REG1 bits */
+static const uint8_t ST = 0;        // Self test enable bit, enabled = 1
+// Enable rates higher than 80 Hz enabled = 1
+static const uint8_t FAST_ODR = 1;
+static const uint8_t DO0 = 2;       // Output data rate bit 2
+static const uint8_t DO1 = 3;       // Output data rate bit 3
+static const uint8_t DO2 = 4;       // Output data rate bit 4
+static const uint8_t OM0 = 5;       // XY operating mode bit 5
+static const uint8_t OM1 = 6;       // XY operating mode bit 6
+static const uint8_t TEMP_EN = 7;   // Temperature sensor enable enabled = 1
+static const uint8_t CTRL_REG1_DEFAULT = (1 << TEMP_EN) | (1 << OM1) |
+        (1 << DO0) | (1 << DO1) | (1 << DO2);
+
+/* CTRL_REG2 bits */
+//reset configuration registers and user registers
+static const uint8_t SOFT_RST = 2;
+static const uint8_t REBOOT = 3;    //reboot memory content
+static const uint8_t FSO = 5;       //full-scale selection bit 5
+static const uint8_t FS1 = 6;       //full-scale selection bit 6
+static const uint8_t CTRL_REG2_DEFAULT = 0;
+
+/* CTRL_REG3 bits */
+static const uint8_t MD0 = 0;       //Operating mode bit 0
+static const uint8_t MD1 = 1;       //Operating mode bit 1
+//SPI serial interface mode selection enabled = 3-wire-mode
+static const uint8_t SIM = 2;
+static const uint8_t LP = 5;        //low-power mode
+static const uint8_t CTRL_REG3_DEFAULT = 0;
+
+/* CTRL_REG4 bits */
+//big/little endian data selection enabled = MSb at lower adress
+static const uint8_t BLE = 1;
+static const uint8_t OMZ0 = 2;      //Z operating mode bit 2
+static const uint8_t OMZ1 = 3;      //Z operating mode bit 3
+static const uint8_t CTRL_REG4_DEFAULT = (1 << OMZ1);
+
+/* CTRL_REG5 bits */
+static const uint8_t BDU = 6;       //Block data update
+static const uint8_t FAST_READ = 7; //Fast read enabled = 1
+static const uint8_t CTRL_REG5_DEFAULT = 0;
+
+static const uint32_t MGM_DATA_SET_ID = READ_CONFIG_AND_DATA;
+
+enum MgmPoolIds: lp_id_t {
+    FIELD_STRENGTH_X,
+    FIELD_STRENGTH_Y,
+    FIELD_STRENGTH_Z,
+    TEMPERATURE_CELCIUS
+};
+
+class MgmPrimaryDataset: public StaticLocalDataSet<4> {
+public:
+    MgmPrimaryDataset(HasLocalDataPoolIF* hkOwner):
+        StaticLocalDataSet(hkOwner, MGM_DATA_SET_ID) {}
+
+    MgmPrimaryDataset(object_id_t mgmId):
+        StaticLocalDataSet(sid_t(mgmId, MGM_DATA_SET_ID)) {}
+
+    lp_var_t<float> fieldStrengthX = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_X, this);
+    lp_var_t<float> fieldStrengthY = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_Y, this);
+    lp_var_t<float> fieldStrengthZ = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_Z, this);
+    lp_var_t<float> temperature = lp_var_t<float>(sid.objectId,
+            TEMPERATURE_CELCIUS, this);
+};
+
+}
+
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_ */

hal/src/fsfw_hal/devicehandlers/devicedefinitions/MgmRM3100HandlerDefs.h

@@ -0,0 +1,132 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/serialize/SerialLinkedListAdapter.h>
+#include <cstdint>
+
+namespace RM3100 {
+
+/* Actually 10, we round up a little bit */
+static constexpr size_t MAX_BUFFER_SIZE = 12;
+
+static constexpr uint8_t READ_MASK = 0x80;
+
+/*----------------------------------------------------------------------------*/
+/* CMM Register */
+/*----------------------------------------------------------------------------*/
+static constexpr uint8_t SET_CMM_CMZ = 1 << 6;
+static constexpr uint8_t SET_CMM_CMY = 1 << 5;
+static constexpr uint8_t SET_CMM_CMX = 1 << 4;
+static constexpr uint8_t SET_CMM_DRDM = 1 << 2;
+static constexpr uint8_t SET_CMM_START = 1;
+static constexpr uint8_t CMM_REGISTER = 0x01;
+
+static constexpr uint8_t CMM_VALUE = SET_CMM_CMZ | SET_CMM_CMY | SET_CMM_CMX |
+		SET_CMM_DRDM | SET_CMM_START;
+
+/*----------------------------------------------------------------------------*/
+/* Cycle count register */
+/*----------------------------------------------------------------------------*/
+// Default value (200)
+static constexpr uint8_t CYCLE_COUNT_VALUE = 0xC8;
+
+static constexpr float DEFAULT_GAIN = static_cast<float>(CYCLE_COUNT_VALUE) /
+		100 * 38;
+static constexpr uint8_t CYCLE_COUNT_START_REGISTER = 0x04;
+
+/*----------------------------------------------------------------------------*/
+/* TMRC register */
+/*----------------------------------------------------------------------------*/
+static constexpr uint8_t TMRC_150HZ_VALUE = 0x94;
+static constexpr uint8_t TMRC_75HZ_VALUE = 0x95;
+static constexpr uint8_t TMRC_DEFAULT_37HZ_VALUE = 0x96;
+
+static constexpr uint8_t TMRC_REGISTER = 0x0B;
+static constexpr uint8_t TMRC_DEFAULT_VALUE = TMRC_DEFAULT_37HZ_VALUE;
+
+static constexpr uint8_t MEASUREMENT_REG_START = 0x24;
+static constexpr uint8_t BIST_REGISTER = 0x33;
+static constexpr uint8_t DATA_READY_VAL = 0b10000000;
+static constexpr uint8_t STATUS_REGISTER = 0x34;
+static constexpr uint8_t REVID_REGISTER = 0x36;
+
+// Range in Microtesla. 1 T equals 10000 Gauss (for comparison with LIS3 MGM)
+static constexpr uint16_t RANGE = 800;
+
+static constexpr DeviceCommandId_t READ_DATA = 0;
+
+static constexpr DeviceCommandId_t CONFIGURE_CMM = 1;
+static constexpr DeviceCommandId_t READ_CMM = 2;
+
+static constexpr DeviceCommandId_t CONFIGURE_TMRC = 3;
+static constexpr DeviceCommandId_t READ_TMRC = 4;
+
+static constexpr DeviceCommandId_t CONFIGURE_CYCLE_COUNT = 5;
+static constexpr DeviceCommandId_t READ_CYCLE_COUNT = 6;
+
+class CycleCountCommand: public SerialLinkedListAdapter<SerializeIF> {
+public:
+	CycleCountCommand(bool oneCycleCount = true): oneCycleCount(oneCycleCount) {
+		setLinks(oneCycleCount);
+	}
+
+	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+			Endianness streamEndianness) override {
+		ReturnValue_t result = SerialLinkedListAdapter::deSerialize(buffer,
+				size, streamEndianness);
+		if(oneCycleCount) {
+			cycleCountY = cycleCountX;
+			cycleCountZ = cycleCountX;
+		}
+		return result;
+	}
+
+	SerializeElement<uint16_t> cycleCountX;
+	SerializeElement<uint16_t> cycleCountY;
+	SerializeElement<uint16_t> cycleCountZ;
+
+private:
+	void setLinks(bool oneCycleCount) {
+		setStart(&cycleCountX);
+		if(not oneCycleCount) {
+			cycleCountX.setNext(&cycleCountY);
+			cycleCountY.setNext(&cycleCountZ);
+		}
+	}
+
+	bool oneCycleCount;
+};
+
+static constexpr uint32_t MGM_DATASET_ID = READ_DATA;
+
+enum MgmPoolIds: lp_id_t {
+    FIELD_STRENGTH_X,
+    FIELD_STRENGTH_Y,
+    FIELD_STRENGTH_Z,
+};
+
+class Rm3100PrimaryDataset: public StaticLocalDataSet<3> {
+public:
+	Rm3100PrimaryDataset(HasLocalDataPoolIF* hkOwner):
+        StaticLocalDataSet(hkOwner, MGM_DATASET_ID) {}
+
+	Rm3100PrimaryDataset(object_id_t mgmId):
+        StaticLocalDataSet(sid_t(mgmId, MGM_DATASET_ID)) {}
+
+	// Field strengths in micro Tesla.
+    lp_var_t<float> fieldStrengthX = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_X, this);
+    lp_var_t<float> fieldStrengthY = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_Y, this);
+    lp_var_t<float> fieldStrengthZ = lp_var_t<float>(sid.objectId,
+            FIELD_STRENGTH_Z, this);
+};
+
+}
+
+
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_ */

hal/src/fsfw_hal/host/CMakeLists.txt

@@ -0,0 +1 @@
+

hal/src/fsfw_hal/linux/CMakeLists.txt

@@ -0,0 +1,13 @@
+if(FSFW_HAL_ADD_RASPBERRY_PI)
+    add_subdirectory(rpi)
+endif()
+
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	UnixFileGuard.cpp
+	utility.cpp
+)
+
+add_subdirectory(gpio)
+add_subdirectory(spi)
+add_subdirectory(i2c)
+add_subdirectory(uart)

hal/src/fsfw_hal/linux/UnixFileGuard.cpp

@@ -0,0 +1,37 @@
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+
+#include <cerrno>
+#include <cstring>
+
+UnixFileGuard::UnixFileGuard(std::string device, int* fileDescriptor, int flags,
+        std::string diagnosticPrefix):
+        fileDescriptor(fileDescriptor) {
+    if(fileDescriptor == nullptr) {
+        return;
+    }
+    *fileDescriptor = open(device.c_str(), flags);
+    if (*fileDescriptor < 0) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << diagnosticPrefix << ": Opening device failed with error code " <<
+                errno << ": " << strerror(errno) << std::endl;
+#else
+        sif::printWarning("%s: Opening device failed with error code %d: %s\n",
+                diagnosticPrefix, errno, strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        openStatus = OPEN_FILE_FAILED;
+    }
+}
+
+UnixFileGuard::~UnixFileGuard() {
+    if(fileDescriptor != nullptr) {
+        close(*fileDescriptor);
+    }
+}
+
+ReturnValue_t UnixFileGuard::getOpenResult() const {
+    return openStatus;
+}

hal/src/fsfw_hal/linux/UnixFileGuard.h

@@ -0,0 +1,33 @@
+#ifndef LINUX_UTILITY_UNIXFILEGUARD_H_
+#define LINUX_UTILITY_UNIXFILEGUARD_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <string>
+
+#include <fcntl.h>
+#include <unistd.h>
+
+
+class UnixFileGuard {
+public:
+    static constexpr int READ_WRITE_FLAG = O_RDWR;
+    static constexpr int READ_ONLY_FLAG = O_RDONLY;
+    static constexpr int NON_BLOCKING_IO_FLAG = O_NONBLOCK;
+
+    static constexpr ReturnValue_t OPEN_FILE_FAILED = 1;
+
+    UnixFileGuard(std::string device, int* fileDescriptor, int flags,
+            std::string diagnosticPrefix = "");
+
+    virtual~ UnixFileGuard();
+
+    ReturnValue_t getOpenResult() const;
+private:
+    int* fileDescriptor = nullptr;
+    ReturnValue_t openStatus = HasReturnvaluesIF::RETURN_OK;
+};
+
+
+
+#endif /* LINUX_UTILITY_UNIXFILEGUARD_H_ */

hal/src/fsfw_hal/linux/gpio/CMakeLists.txt

@@ -0,0 +1,12 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    LinuxLibgpioIF.cpp
+)
+
+# This abstraction layer requires the gpiod library. You can install this library
+# with "sudo apt-get install -y libgpiod-dev". If you are cross-compiling, you need
+# to install the package before syncing the sysroot to your host computer.
+find_library(LIB_GPIO gpiod REQUIRED)
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${LIB_GPIO}
+)

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

@@ -0,0 +1,344 @@
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+#include <utility>
+#include <unistd.h>
+#include <gpiod.h>
+
+LinuxLibgpioIF::LinuxLibgpioIF(object_id_t objectId) : SystemObject(objectId) {
+}
+
+LinuxLibgpioIF::~LinuxLibgpioIF() {
+    for(auto& config: gpioMap) {
+        delete(config.second);
+    }
+}
+
+ReturnValue_t LinuxLibgpioIF::addGpios(GpioCookie* gpioCookie) {
+    ReturnValue_t result;
+    if(gpioCookie == nullptr) {
+        sif::error << "LinuxLibgpioIF::addGpios: Invalid cookie" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    GpioMap mapToAdd = gpioCookie->getGpioMap();
+
+    /* Check whether this ID already exists in the map and remove duplicates */
+    result = checkForConflicts(mapToAdd);
+    if (result != RETURN_OK){
+        return result;
+    }
+
+    result = configureGpios(mapToAdd);
+    if (result != RETURN_OK) {
+        return RETURN_FAILED;
+    }
+
+    /* Register new GPIOs in gpioMap */
+    gpioMap.insert(mapToAdd.begin(), mapToAdd.end());
+
+    return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::configureGpios(GpioMap& mapToAdd) {
+    for(auto& gpioConfig: mapToAdd) {
+        auto& gpioType = gpioConfig.second->gpioType;
+        switch(gpioType) {
+        case(gpio::GpioTypes::NONE): {
+            return GPIO_INVALID_INSTANCE;
+        }
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP): {
+            auto regularGpio = dynamic_cast<GpiodRegularByChip*>(gpioConfig.second);
+            if(regularGpio == nullptr) {
+                return GPIO_INVALID_INSTANCE;
+            }
+            configureGpioByChip(gpioConfig.first, *regularGpio);
+            break;
+        }
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL):{
+            auto regularGpio = dynamic_cast<GpiodRegularByLabel*>(gpioConfig.second);
+            if(regularGpio == nullptr) {
+                return GPIO_INVALID_INSTANCE;
+            }
+            configureGpioByLabel(gpioConfig.first, *regularGpio);
+            break;
+        }
+        case(gpio::GpioTypes::CALLBACK): {
+            auto gpioCallback = dynamic_cast<GpioCallback*>(gpioConfig.second);
+            if(gpioCallback->callback == nullptr) {
+                return GPIO_INVALID_INSTANCE;
+            }
+            gpioCallback->callback(gpioConfig.first, gpio::GpioOperation::WRITE,
+                    gpioCallback->initValue, gpioCallback->callbackArgs);
+        }
+        }
+    }
+    return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::configureGpioByLabel(gpioId_t gpioId,
+        GpiodRegularByLabel &gpioByLabel) {
+    std::string& label = gpioByLabel.label;
+    struct gpiod_chip* chip = gpiod_chip_open_by_label(label.c_str());
+    if (chip == nullptr) {
+        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open gpio from gpio "
+                << "group with label " << label << ". Gpio ID: " << gpioId << std::endl;
+        return RETURN_FAILED;
+
+    }
+    std::string failOutput = "label: " + label;
+    return configureRegularGpio(gpioId, gpioByLabel.gpioType, chip, gpioByLabel, failOutput);
+}
+
+ReturnValue_t LinuxLibgpioIF::configureGpioByChip(gpioId_t gpioId,
+        GpiodRegularByChip &gpioByChip) {
+    std::string& chipname = gpioByChip.chipname;
+    struct gpiod_chip* chip = gpiod_chip_open_by_name(chipname.c_str());
+    if (chip == nullptr) {
+        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open chip "
+                << chipname << ". Gpio ID: " << gpioId << std::endl;
+        return RETURN_FAILED;
+    }
+    std::string failOutput = "chipname: " + chipname;
+    return configureRegularGpio(gpioId, gpioByChip.gpioType, chip, gpioByChip, failOutput);
+}
+
+ReturnValue_t LinuxLibgpioIF::configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+        struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput) {
+    unsigned int lineNum;
+    gpio::Direction direction;
+    std::string consumer;
+    struct gpiod_line *lineHandle;
+    int result = 0;
+
+    lineNum = regularGpio.lineNum;
+    lineHandle = gpiod_chip_get_line(chip, lineNum);
+    if (!lineHandle) {
+        sif::warning << "LinuxLibgpioIF::configureRegularGpio: Failed to open line " << std::endl;
+        sif::warning << "GPIO ID: " << gpioId << ", line number: " << lineNum <<
+                ", " << failOutput << std::endl;
+        sif::warning << "Check if Linux GPIO configuration has changed. " << std::endl;
+        gpiod_chip_close(chip);
+        return RETURN_FAILED;
+    }
+
+    direction = regularGpio.direction;
+    consumer = regularGpio.consumer;
+    /* Configure direction and add a description to the GPIO */
+    switch (direction) {
+    case(gpio::OUT): {
+        result = gpiod_line_request_output(lineHandle, consumer.c_str(),
+                regularGpio.initValue);
+        if (result < 0) {
+            sif::error << "LinuxLibgpioIF::configureRegularGpio: Failed to request line " << lineNum <<
+                    " from GPIO instance with ID: " << gpioId << std::endl;
+            gpiod_line_release(lineHandle);
+            return RETURN_FAILED;
+        }
+        break;
+    }
+    case(gpio::IN): {
+        result = gpiod_line_request_input(lineHandle, consumer.c_str());
+        if (result < 0) {
+            sif::error << "LinuxLibgpioIF::configureGpios: Failed to request line "
+                    << lineNum << " from GPIO instance with ID: " << gpioId << std::endl;
+            gpiod_line_release(lineHandle);
+            return RETURN_FAILED;
+        }
+        break;
+    }
+    default: {
+        sif::error << "LinuxLibgpioIF::configureGpios: Invalid direction specified"
+                << std::endl;
+        return GPIO_INVALID_INSTANCE;
+    }
+
+    }
+    /**
+     * Write line handle to GPIO configuration instance so it can later be used to set or
+     * read states of GPIOs.
+     */
+    regularGpio.lineHandle = lineHandle;
+    return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::pullHigh(gpioId_t gpioId) {
+    gpioMapIter = gpioMap.find(gpioId);
+    if (gpioMapIter == gpioMap.end()) {
+        sif::warning << "LinuxLibgpioIF::pullHigh: Unknown GPIO ID " << gpioId << std::endl;
+        return UNKNOWN_GPIO_ID;
+    }
+
+    auto gpioType = gpioMapIter->second->gpioType;
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+        auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        if(regularGpio == nullptr) {
+            return GPIO_TYPE_FAILURE;
+        }
+        return driveGpio(gpioId, *regularGpio, gpio::HIGH);
+    }
+    else {
+        auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
+        if(gpioCallback->callback == nullptr) {
+            return GPIO_INVALID_INSTANCE;
+        }
+        gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
+                1, gpioCallback->callbackArgs);
+        return RETURN_OK;
+    }
+    return GPIO_TYPE_FAILURE;
+}
+
+ReturnValue_t LinuxLibgpioIF::pullLow(gpioId_t gpioId) {
+    gpioMapIter = gpioMap.find(gpioId);
+    if (gpioMapIter == gpioMap.end()) {
+        sif::warning << "LinuxLibgpioIF::pullLow: Unknown GPIO ID " << gpioId << std::endl;
+        return UNKNOWN_GPIO_ID;
+    }
+
+    auto& gpioType = gpioMapIter->second->gpioType;
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+        auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        if(regularGpio == nullptr) {
+            return GPIO_TYPE_FAILURE;
+        }
+        return driveGpio(gpioId, *regularGpio, gpio::LOW);
+    }
+    else {
+        auto gpioCallback = dynamic_cast<GpioCallback*>(gpioMapIter->second);
+        if(gpioCallback->callback == nullptr) {
+            return GPIO_INVALID_INSTANCE;
+        }
+        gpioCallback->callback(gpioMapIter->first, gpio::GpioOperation::WRITE,
+                0, gpioCallback->callbackArgs);
+        return RETURN_OK;
+    }
+    return GPIO_TYPE_FAILURE;
+}
+
+ReturnValue_t LinuxLibgpioIF::driveGpio(gpioId_t gpioId,
+        GpiodRegularBase& regularGpio, gpio::Levels logicLevel) {
+    int result = gpiod_line_set_value(regularGpio.lineHandle, logicLevel);
+    if (result < 0) {
+        sif::warning << "LinuxLibgpioIF::driveGpio: Failed to pull GPIO with ID " << gpioId <<
+                " to logic level " << logicLevel << std::endl;
+        return DRIVE_GPIO_FAILURE;
+    }
+
+    return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
+    gpioMapIter = gpioMap.find(gpioId);
+    if (gpioMapIter == gpioMap.end()){
+        sif::warning << "LinuxLibgpioIF::readGpio: Unknown GPIOD ID " << gpioId << std::endl;
+        return UNKNOWN_GPIO_ID;
+    }
+    auto gpioType = gpioMapIter->second->gpioType;
+    if(gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_CHIP or
+            gpioType == gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+        auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        if(regularGpio == nullptr) {
+            return GPIO_TYPE_FAILURE;
+        }
+        *gpioState = gpiod_line_get_value(regularGpio->lineHandle);
+    }
+    else {
+
+    }
+
+
+    return RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::checkForConflicts(GpioMap& mapToAdd){
+    ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    for(auto& gpioConfig: mapToAdd) {
+        switch(gpioConfig.second->gpioType) {
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_CHIP):
+        case(gpio::GpioTypes::GPIO_REGULAR_BY_LABEL): {
+            auto regularGpio = dynamic_cast<GpiodRegularBase*>(gpioConfig.second);
+            if(regularGpio == nullptr)  {
+                return GPIO_TYPE_FAILURE;
+            }
+            /* Check for conflicts and remove duplicates if necessary */
+            result = checkForConflictsRegularGpio(gpioConfig.first, *regularGpio, mapToAdd);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            break;
+        }
+        case(gpio::GpioTypes::CALLBACK): {
+            auto callbackGpio = dynamic_cast<GpioCallback*>(gpioConfig.second);
+            if(callbackGpio == nullptr)  {
+                return GPIO_TYPE_FAILURE;
+            }
+            /* Check for conflicts and remove duplicates if necessary */
+            result = checkForConflictsCallbackGpio(gpioConfig.first, callbackGpio, mapToAdd);
+            if(result != HasReturnvaluesIF::RETURN_OK) {
+                status = result;
+            }
+            break;
+        }
+        default: {
+
+        }
+        }
+    }
+    return status;
+}
+
+
+ReturnValue_t LinuxLibgpioIF::checkForConflictsRegularGpio(gpioId_t gpioIdToCheck,
+        GpiodRegularBase& gpioToCheck, GpioMap& mapToAdd) {
+    /* Cross check with private map */
+    gpioMapIter = gpioMap.find(gpioIdToCheck);
+    if(gpioMapIter != gpioMap.end()) {
+        auto& gpioType = gpioMapIter->second->gpioType;
+        if(gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_CHIP and
+                gpioType != gpio::GpioTypes::GPIO_REGULAR_BY_LABEL) {
+            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
+            mapToAdd.erase(gpioIdToCheck);
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+        auto ownRegularGpio = dynamic_cast<GpiodRegularBase*>(gpioMapIter->second);
+        if(ownRegularGpio == nullptr) {
+            return GPIO_TYPE_FAILURE;
+        }
+
+        /* Remove element from map to add because a entry for this GPIO
+        already exists */
+        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                << " detected. Duplicate will be removed from map to add." << std::endl;
+        mapToAdd.erase(gpioIdToCheck);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LinuxLibgpioIF::checkForConflictsCallbackGpio(gpioId_t gpioIdToCheck,
+        GpioCallback *callbackGpio, GpioMap& mapToAdd) {
+    /* Cross check with private map */
+    gpioMapIter = gpioMap.find(gpioIdToCheck);
+    if(gpioMapIter != gpioMap.end()) {
+        if(gpioMapIter->second->gpioType != gpio::GpioTypes::CALLBACK) {
+            sif::warning << "LinuxLibgpioIF::checkForConflicts: ID already exists for different "
+                    "GPIO type" << gpioIdToCheck << ". Removing duplicate." << std::endl;
+            mapToAdd.erase(gpioIdToCheck);
+            return HasReturnvaluesIF::RETURN_OK;
+        }
+
+        /* Remove element from map to add because a entry for this GPIO
+        already exists */
+        sif::warning << "LinuxLibgpioIF::checkForConflictsRegularGpio: Duplicate GPIO definition"
+                << " detected. Duplicate will be removed from map to add." << std::endl;
+        mapToAdd.erase(gpioIdToCheck);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}

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

@@ -0,0 +1,82 @@
+#ifndef LINUX_GPIO_LINUXLIBGPIOIF_H_
+#define LINUX_GPIO_LINUXLIBGPIOIF_H_
+
+#include "../../common/gpio/GpioIF.h"
+#include <returnvalues/classIds.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class GpioCookie;
+class GpiodRegularIF;
+
+/**
+ * @brief	This class implements the GpioIF for a linux based system. The
+ * 			implementation is based on the libgpiod lib which requires linux 4.8
+ * 			or higher.
+ * @note	The Petalinux SDK from Xilinx supports libgpiod since Petalinux
+ * 			2019.1.
+ */
+class LinuxLibgpioIF : public GpioIF, public SystemObject {
+public:
+
+    static const uint8_t gpioRetvalId = CLASS_ID::HAL_GPIO;
+
+    static constexpr ReturnValue_t UNKNOWN_GPIO_ID =
+            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 1);
+    static constexpr ReturnValue_t DRIVE_GPIO_FAILURE =
+            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 2);
+    static constexpr ReturnValue_t GPIO_TYPE_FAILURE =
+            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 3);
+    static constexpr ReturnValue_t GPIO_INVALID_INSTANCE =
+            HasReturnvaluesIF::makeReturnCode(gpioRetvalId, 4);
+
+	LinuxLibgpioIF(object_id_t objectId);
+	virtual ~LinuxLibgpioIF();
+
+	ReturnValue_t addGpios(GpioCookie* gpioCookie) override;
+	ReturnValue_t pullHigh(gpioId_t gpioId) override;
+	ReturnValue_t pullLow(gpioId_t gpioId) override;
+	ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState) override;
+
+private:
+	/* Holds the information and configuration of all used GPIOs */
+	GpioUnorderedMap gpioMap;
+	GpioUnorderedMapIter gpioMapIter;
+
+	/**
+	 * @brief	This functions drives line of a GPIO specified by the GPIO ID.
+	 *
+	 * @param gpioId	The GPIO ID of the GPIO to drive.
+	 * @param logiclevel	The logic level to set. O or 1.
+	 */
+	ReturnValue_t driveGpio(gpioId_t gpioId, GpiodRegularBase& regularGpio,
+	        gpio::Levels logicLevel);
+
+	ReturnValue_t configureGpioByLabel(gpioId_t gpioId, GpiodRegularByLabel& gpioByLabel);
+	ReturnValue_t configureGpioByChip(gpioId_t gpioId, GpiodRegularByChip& gpioByChip);
+    ReturnValue_t configureRegularGpio(gpioId_t gpioId, gpio::GpioTypes gpioType,
+            struct gpiod_chip* chip, GpiodRegularBase& regularGpio, std::string failOutput);
+
+	/**
+	 * @brief	This function checks if GPIOs are already registered and whether
+	 * 			there exists a conflict in the GPIO configuration. E.g. the
+	 * 			direction.
+	 *
+	 * @param mapToAdd	The GPIOs which shall be added to the gpioMap.
+	 *
+	 * @return	RETURN_OK if successful, otherwise RETURN_FAILED
+	 */
+	ReturnValue_t checkForConflicts(GpioMap& mapToAdd);
+
+	ReturnValue_t checkForConflictsRegularGpio(gpioId_t gpiodId, GpiodRegularBase& regularGpio,
+	        GpioMap& mapToAdd);
+    ReturnValue_t checkForConflictsCallbackGpio(gpioId_t gpiodId, GpioCallback* regularGpio,
+            GpioMap& mapToAdd);
+
+	/**
+	 * @brief   Performs the initial configuration of all GPIOs specified in the GpioMap mapToAdd.
+	 */
+	ReturnValue_t configureGpios(GpioMap& mapToAdd);
+
+};
+
+#endif /* LINUX_GPIO_LINUXLIBGPIOIF_H_ */

hal/src/fsfw_hal/linux/i2c/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    I2cComIF.cpp
+    I2cCookie.cpp
+)
+
+
+
+

hal/src/fsfw_hal/linux/i2c/I2cComIF.cpp

@@ -0,0 +1,205 @@
+#include "fsfw_hal/linux/i2c/I2cComIF.h"
+#include "fsfw_hal/linux/utility.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/i2c-dev.h>
+#include <errno.h>
+
+#include <cstring>
+
+
+I2cComIF::I2cComIF(object_id_t objectId): SystemObject(objectId){
+}
+
+I2cComIF::~I2cComIF() {}
+
+ReturnValue_t I2cComIF::initializeInterface(CookieIF* cookie) {
+
+    address_t i2cAddress;
+    std::string deviceFile;
+
+    if(cookie == nullptr) {
+        sif::error << "I2cComIF::initializeInterface: Invalid cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+    if(i2cCookie == nullptr) {
+        sif::error << "I2cComIF::initializeInterface: Invalid I2C cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    i2cAddress = i2cCookie->getAddress();
+
+    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+    if(i2cDeviceMapIter == i2cDeviceMap.end()) {
+        size_t maxReplyLen = i2cCookie->getMaxReplyLen();
+        I2cInstance i2cInstance = {std::vector<uint8_t>(maxReplyLen), 0};
+        auto statusPair = i2cDeviceMap.emplace(i2cAddress, i2cInstance);
+        if (not statusPair.second) {
+            sif::error << "I2cComIF::initializeInterface: Failed to insert device with address " <<
+                    i2cAddress << "to I2C device " << "map" << std::endl;
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    sif::error << "I2cComIF::initializeInterface: Device with address " << i2cAddress <<
+            "already in use" << std::endl;
+    return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t I2cComIF::sendMessage(CookieIF *cookie,
+        const uint8_t *sendData, size_t sendLen) {
+
+    ReturnValue_t result;
+    int fd;
+    std::string deviceFile;
+
+    if(sendData == nullptr) {
+        sif::error << "I2cComIF::sendMessage: Send Data is nullptr"
+                << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    if(sendLen == 0) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+    if(i2cCookie == nullptr) {
+        sif::error << "I2cComIF::sendMessage: Invalid I2C Cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    address_t i2cAddress = i2cCookie->getAddress();
+    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+        sif::error << "I2cComIF::sendMessage: i2cAddress of Cookie not "
+                << "registered in i2cDeviceMap" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    deviceFile = i2cCookie->getDeviceFile();
+    UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::sendMessage");
+    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+        return fileHelper.getOpenResult();
+    }
+    result = openDevice(deviceFile, i2cAddress, &fd);
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        return result;
+    }
+
+    if (write(fd, sendData, sendLen) != (int)sendLen) {
+        sif::error << "I2cComIF::sendMessage: Failed to send data to I2C "
+                "device with error code " << errno << ". Error description: "
+                << strerror(errno) << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::getSendSuccess(CookieIF *cookie) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::requestReceiveMessage(CookieIF *cookie,
+        size_t requestLen) {
+    ReturnValue_t result;
+    int fd;
+    std::string deviceFile;
+
+    if (requestLen == 0) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+    if(i2cCookie == nullptr) {
+        sif::error << "I2cComIF::requestReceiveMessage: Invalid I2C Cookie!" << std::endl;
+        i2cDeviceMapIter->second.replyLen = 0;
+        return NULLPOINTER;
+    }
+
+    address_t i2cAddress = i2cCookie->getAddress();
+    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+        sif::error << "I2cComIF::requestReceiveMessage: i2cAddress of Cookie not "
+                << "registered in i2cDeviceMap" << std::endl;
+        i2cDeviceMapIter->second.replyLen = 0;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    deviceFile = i2cCookie->getDeviceFile();
+    UnixFileGuard fileHelper(deviceFile, &fd, O_RDWR, "I2cComIF::requestReceiveMessage");
+    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+        return fileHelper.getOpenResult();
+    }
+    result = openDevice(deviceFile, i2cAddress, &fd);
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        i2cDeviceMapIter->second.replyLen = 0;
+        return result;
+    }
+
+    uint8_t* replyBuffer = i2cDeviceMapIter->second.replyBuffer.data();
+
+    int readLen = read(fd, replyBuffer, requestLen);
+    if (readLen != static_cast<int>(requestLen)) {
+#if FSFW_VERBOSE_LEVEL >= 1 and FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "I2cComIF::requestReceiveMessage: Reading from I2C "
+                << "device failed with error code " << errno <<". Description"
+                << " of error: " << strerror(errno) << std::endl;
+        sif::error << "I2cComIF::requestReceiveMessage: Read only " << readLen << " from "
+                << requestLen << " bytes" << std::endl;
+#endif
+        i2cDeviceMapIter->second.replyLen = 0;
+        sif::debug << "I2cComIF::requestReceiveMessage: Read "  << readLen << " of " << requestLen << " bytes" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    i2cDeviceMapIter->second.replyLen = requestLen;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::readReceivedMessage(CookieIF *cookie,
+        uint8_t **buffer, size_t* size) {
+    I2cCookie* i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+    if(i2cCookie == nullptr) {
+        sif::error << "I2cComIF::readReceivedMessage: Invalid I2C Cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    address_t i2cAddress = i2cCookie->getAddress();
+    i2cDeviceMapIter = i2cDeviceMap.find(i2cAddress);
+    if (i2cDeviceMapIter == i2cDeviceMap.end()) {
+        sif::error << "I2cComIF::readReceivedMessage: i2cAddress of Cookie not "
+                << "found in i2cDeviceMap" << std::endl;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    *buffer = i2cDeviceMapIter->second.replyBuffer.data();
+    *size = i2cDeviceMapIter->second.replyLen;
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t I2cComIF::openDevice(std::string deviceFile,
+        address_t i2cAddress, int* fileDescriptor) {
+
+    if (ioctl(*fileDescriptor, I2C_SLAVE, i2cAddress) < 0) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "I2cComIF: Specifying target device failed with error code " << errno << "."
+                << std::endl;
+        sif::warning << "Error description " << strerror(errno) << std::endl;
+#else
+        sif::printWarning("I2cComIF: Specifying target device failed with error code %d.\n");
+        sif::printWarning("Error description: %s\n", strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}

hal/src/fsfw_hal/linux/i2c/I2cComIF.h

@@ -0,0 +1,61 @@
+#ifndef LINUX_I2C_I2COMIF_H_
+#define LINUX_I2C_I2COMIF_H_
+
+#include "I2cCookie.h"
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+
+#include <unordered_map>
+#include <vector>
+
+/**
+ * @brief 	This is the communication interface for I2C devices connected
+ * 			to a system running a Linux OS.
+ *
+ * @note    The Xilinx Linux kernel might not support to read more than 255 bytes at once.
+ *
+ * @author 	J. Meier
+ */
+class I2cComIF: public DeviceCommunicationIF, public SystemObject {
+public:
+	I2cComIF(object_id_t objectId);
+
+	virtual ~I2cComIF();
+
+	ReturnValue_t initializeInterface(CookieIF * cookie) override;
+	ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
+			size_t sendLen) override;
+	ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+	ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+	        size_t requestLen) override;
+	ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+			size_t *size) override;
+
+private:
+
+	struct I2cInstance {
+		std::vector<uint8_t> replyBuffer;
+		size_t replyLen;
+	};
+
+	using I2cDeviceMap = std::unordered_map<address_t, I2cInstance>;
+	using I2cDeviceMapIter = I2cDeviceMap::iterator;
+
+	/* In this map all i2c devices will be registered with their address and
+	 * the appropriate file descriptor will be stored */
+	I2cDeviceMap i2cDeviceMap;
+	I2cDeviceMapIter i2cDeviceMapIter;
+
+	/**
+	 * @brief	This function opens an I2C device and binds the opened file
+	 * 			to a specific I2C address.
+	 * @param deviceFile	The name of the device file. E.g. i2c-0
+	 * @param i2cAddress	The address of the i2c slave device.
+	 * @param fileDescriptor	Pointer to device descriptor.
+	 * @return	RETURN_OK if successful, otherwise RETURN_FAILED.
+	 */
+	ReturnValue_t openDevice(std::string deviceFile,
+			address_t i2cAddress, int* fileDescriptor);
+};
+
+#endif /* LINUX_I2C_I2COMIF_H_ */

hal/src/fsfw_hal/linux/i2c/I2cCookie.cpp

@@ -0,0 +1,20 @@
+#include "fsfw_hal/linux/i2c/I2cCookie.h"
+
+I2cCookie::I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
+		std::string deviceFile_) :
+		i2cAddress(i2cAddress_), maxReplyLen(maxReplyLen_), deviceFile(deviceFile_) {
+}
+
+address_t I2cCookie::getAddress() const {
+	return i2cAddress;
+}
+
+size_t I2cCookie::getMaxReplyLen() const {
+	return maxReplyLen;
+}
+
+std::string I2cCookie::getDeviceFile() const {
+	return deviceFile;
+}
+
+I2cCookie::~I2cCookie() {}

hal/src/fsfw_hal/linux/i2c/I2cCookie.h

@@ -0,0 +1,38 @@
+#ifndef LINUX_I2C_I2CCOOKIE_H_
+#define LINUX_I2C_I2CCOOKIE_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <string>
+
+/**
+ * @brief   Cookie for the i2cDeviceComIF.
+ *
+ * @author 	J. Meier
+ */
+class I2cCookie: public CookieIF {
+public:
+
+	/**
+	 * @brief	Constructor for the I2C cookie.
+	 * @param i2cAddress_	The i2c address of the target device.
+	 * @param maxReplyLen_	The maximum expected length of a reply from the
+	 * 						target device.
+	 * @param devicFile_    The device file specifying the i2c interface to use. E.g. "/dev/i2c-0".
+	 */
+	I2cCookie(address_t i2cAddress_, size_t maxReplyLen_,
+			std::string deviceFile_);
+
+	virtual ~I2cCookie();
+
+	address_t getAddress() const;
+	size_t getMaxReplyLen() const;
+	std::string getDeviceFile() const;
+
+private:
+
+	address_t i2cAddress = 0;
+	size_t maxReplyLen = 0;
+	std::string deviceFile;
+};
+
+#endif /* LINUX_I2C_I2CCOOKIE_H_ */

hal/src/fsfw_hal/linux/rpi/CMakeLists.txt

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

hal/src/fsfw_hal/linux/rpi/GpioRPi.cpp

@@ -0,0 +1,38 @@
+#include "fsfw/FSFW.h"
+
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+
+ReturnValue_t gpio::createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
+        std::string consumer, gpio::Direction direction, int initValue) {
+    if(cookie == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    auto config = new GpiodRegularByChip();
+    /* Default chipname for Raspberry Pi. There is still gpiochip1 for expansion, but most users
+    will not need this */
+    config->chipname = "gpiochip0";
+
+    config->consumer = consumer;
+    config->direction = direction;
+    config->initValue = initValue;
+
+    /* Sanity check for the BCM pins before assigning it */
+    if(bcmPin > 27) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "createRpiGpioConfig: BCM pin " << bcmPin << " invalid!" << std::endl;
+#else
+        sif::printError("createRpiGpioConfig: BCM pin %d invalid!\n", bcmPin);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    config->lineNum = bcmPin;
+    cookie->addGpio(gpioId, config);
+    return HasReturnvaluesIF::RETURN_OK;
+}

hal/src/fsfw_hal/linux/rpi/GpioRPi.h

@@ -0,0 +1,26 @@
+#ifndef BSP_RPI_GPIO_GPIORPI_H_
+#define BSP_RPI_GPIO_GPIORPI_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include "../../common/gpio/gpioDefinitions.h"
+
+class GpioCookie;
+
+namespace gpio {
+
+/**
+ * Create a GpioConfig_t. This function does a sanity check on the BCM pin number and fails if the
+ * BCM pin is invalid.
+ * @param cookie    Adds the configuration to this cookie directly
+ * @param gpioId    ID which identifies the GPIO configuration
+ * @param bcmPin    Raspberry Pi BCM pin
+ * @param consumer  Information string
+ * @param direction GPIO direction
+ * @param initValue Intial value for output pins, 0 for low, 1 for high
+ * @return
+ */
+ReturnValue_t createRpiGpioConfig(GpioCookie* cookie, gpioId_t gpioId, int bcmPin,
+        std::string consumer, gpio::Direction direction, int initValue);
+}
+
+#endif /* BSP_RPI_GPIO_GPIORPI_H_ */

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

@@ -0,0 +1,8 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+    SpiComIF.cpp
+    SpiCookie.cpp
+)
+
+
+
+

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

@@ -0,0 +1,408 @@
+#include "fsfw/FSFW.h"
+#include "fsfw_hal/linux/spi/SpiComIF.h"
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+#include "fsfw_hal/linux/utility.h"
+#include "fsfw_hal/linux/UnixFileGuard.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
+
+#include <linux/spi/spidev.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+
+#include <cerrno>
+#include <cstring>
+
+SpiComIF::SpiComIF(object_id_t objectId, GpioIF* gpioComIF):
+        SystemObject(objectId), gpioComIF(gpioComIF) {
+    if(gpioComIF == nullptr) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "SpiComIF::SpiComIF: GPIO communication interface invalid!" << std::endl;
+#else
+        sif::printError("SpiComIF::SpiComIF: GPIO communication interface invalid!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+    }
+
+    spiMutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
+    int retval = 0;
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+        return NULLPOINTER;
+    }
+
+    address_t spiAddress = spiCookie->getSpiAddress();
+
+    auto iter = spiDeviceMap.find(spiAddress);
+    if(iter == spiDeviceMap.end()) {
+        size_t bufferSize = spiCookie->getMaxBufferSize();
+        SpiInstance spiInstance(bufferSize);
+        auto statusPair = spiDeviceMap.emplace(spiAddress, spiInstance);
+        if (not statusPair.second) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::initializeInterface: Failed to insert device with address " <<
+                    spiAddress << "to SPI device map" << std::endl;
+#else
+            sif::printError("SpiComIF::initializeInterface: Failed to insert device with address "
+                    "%lu to SPI device map\n", static_cast<unsigned long>(spiAddress));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        /* Now we emplaced the read buffer in the map, we still need to assign that location
+        to the SPI driver transfer struct */
+        spiCookie->assignReadBuffer(statusPair.first->second.replyBuffer.data());
+    }
+    else {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "SpiComIF::initializeInterface: SPI address already exists!" << std::endl;
+#else
+        sif::printError("SpiComIF::initializeInterface: SPI address already exists!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    /* Pull CS high in any case to be sure that device is inactive */
+    gpioId_t gpioId = spiCookie->getChipSelectPin();
+    if(gpioId != gpio::NO_GPIO) {
+        gpioComIF->pullHigh(gpioId);
+    }
+
+    uint32_t spiSpeed = 0;
+    spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+
+    SpiCookie::UncommonParameters params;
+    spiCookie->getSpiParameters(spiMode, spiSpeed, &params);
+
+    int fileDescriptor = 0;
+    UnixFileGuard fileHelper(spiCookie->getSpiDevice(), &fileDescriptor, O_RDWR,
+            "SpiComIF::initializeInterface");
+    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+        return fileHelper.getOpenResult();
+    }
+
+    /* These flags are rather uncommon */
+    if(params.threeWireSpi or params.noCs or params.csHigh) {
+        uint32_t currentMode = 0;
+        retval = ioctl(fileDescriptor, SPI_IOC_RD_MODE32, &currentMode);
+        if(retval != 0) {
+            utility::handleIoctlError("SpiComIF::initialiezInterface: Could not read full mode!");
+        }
+
+        if(params.threeWireSpi) {
+            currentMode |= SPI_3WIRE;
+        }
+        if(params.noCs) {
+            /* Some drivers like the Raspberry Pi ignore this flag in any case */
+            currentMode |= SPI_NO_CS;
+        }
+        if(params.csHigh) {
+            currentMode |= SPI_CS_HIGH;
+        }
+        /* Write adapted mode */
+        retval = ioctl(fileDescriptor, SPI_IOC_WR_MODE32, &currentMode);
+        if(retval != 0) {
+            utility::handleIoctlError("SpiComIF::initialiezInterface: Could not write full mode!");
+        }
+    }
+    if(params.lsbFirst) {
+        retval = ioctl(fileDescriptor, SPI_IOC_WR_LSB_FIRST, &params.lsbFirst);
+        if(retval != 0) {
+            utility::handleIoctlError("SpiComIF::initializeInterface: Setting LSB first failed");
+        }
+    }
+    if(params.bitsPerWord != 8) {
+        retval = ioctl(fileDescriptor, SPI_IOC_WR_BITS_PER_WORD, &params.bitsPerWord);
+        if(retval != 0) {
+            utility::handleIoctlError("SpiComIF::initializeInterface: "
+                    "Could not write bits per word!");
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+
+    if(spiCookie == nullptr) {
+        return NULLPOINTER;
+    }
+
+    if(sendLen > spiCookie->getMaxBufferSize()) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpiComIF::sendMessage: Too much data sent, send length " << sendLen <<
+                "larger than maximum buffer length " << spiCookie->getMaxBufferSize() << std::endl;
+#else
+        sif::printWarning("SpiComIF::sendMessage: Too much data sent, send length %lu larger "
+                "than maximum buffer length %lu!\n", static_cast<unsigned long>(sendLen),
+                static_cast<unsigned long>(spiCookie->getMaxBufferSize()));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        return DeviceCommunicationIF::TOO_MUCH_DATA;
+    }
+
+    if(spiCookie->getComIfMode() == spi::SpiComIfModes::REGULAR) {
+        result = performRegularSendOperation(spiCookie, sendData, sendLen);
+    }
+    else if(spiCookie->getComIfMode() == spi::SpiComIfModes::CALLBACK) {
+        spi::send_callback_function_t sendFunc = nullptr;
+        void* funcArgs = nullptr;
+        spiCookie->getCallback(&sendFunc, &funcArgs);
+        if(sendFunc != nullptr) {
+            result = sendFunc(this, spiCookie, sendData, sendLen, funcArgs);
+        }
+    }
+    return result;
+}
+
+ReturnValue_t SpiComIF::performRegularSendOperation(SpiCookie *spiCookie, const uint8_t *sendData,
+        size_t sendLen) {
+    address_t spiAddress = spiCookie->getSpiAddress();
+    auto iter = spiDeviceMap.find(spiAddress);
+    if(iter != spiDeviceMap.end()) {
+        spiCookie->assignReadBuffer(iter->second.replyBuffer.data());
+    }
+
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    int retval = 0;
+    /* Prepare transfer */
+    int fileDescriptor = 0;
+    std::string device = spiCookie->getSpiDevice();
+    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+        return OPENING_FILE_FAILED;
+    }
+    spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+    uint32_t spiSpeed = 0;
+    spiCookie->getSpiParameters(spiMode, spiSpeed, nullptr);
+    setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+    spiCookie->assignWriteBuffer(sendData);
+    spiCookie->setTransferSize(sendLen);
+
+    bool fullDuplex = spiCookie->isFullDuplex();
+    gpioId_t gpioId = spiCookie->getChipSelectPin();
+
+    /* Pull SPI CS low. For now, no support for active high given  */
+    if(gpioId != gpio::NO_GPIO) {
+        result = spiMutex->lockMutex(timeoutType, timeoutMs);
+        if (result != RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::sendMessage: Failed to lock mutex" << std::endl;
+#else
+            sif::printError("SpiComIF::sendMessage: Failed to lock mutex\n");
+#endif
+#endif
+            return result;
+        }
+        ReturnValue_t result = gpioComIF->pullLow(gpioId);
+        if(result != HasReturnvaluesIF::RETURN_OK) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "SpiComIF::sendMessage: Pulling low CS pin failed" << std::endl;
+#else
+            sif::printWarning("SpiComIF::sendMessage: Pulling low CS pin failed");
+#endif
+#endif
+            return result;
+        }
+    }
+
+    /* Execute transfer */
+    if(fullDuplex) {
+        /* Initiate a full duplex SPI transfer. */
+        retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), spiCookie->getTransferStructHandle());
+        if(retval < 0) {
+            utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
+            result = FULL_DUPLEX_TRANSFER_FAILED;
+        }
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+        performSpiWiretapping(spiCookie);
+#endif /* FSFW_LINUX_SPI_WIRETAPPING == 1 */
+    }
+    else {
+        /* We write with a blocking half-duplex transfer here */
+        if (write(fileDescriptor, sendData, sendLen) != static_cast<ssize_t>(sendLen)) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "SpiComIF::sendMessage: Half-Duplex write operation failed!" <<
+                    std::endl;
+#else
+            sif::printWarning("SpiComIF::sendMessage: Half-Duplex write operation failed!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+            result = HALF_DUPLEX_TRANSFER_FAILED;
+        }
+    }
+
+    if(gpioId != gpio::NO_GPIO) {
+        gpioComIF->pullHigh(gpioId);
+        result = spiMutex->unlockMutex();
+        if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::sendMessage: Failed to unlock mutex" << std::endl;
+#endif
+            return result;
+        }
+    }
+    return result;
+}
+
+ReturnValue_t SpiComIF::getSendSuccess(CookieIF *cookie) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+        return NULLPOINTER;
+    }
+
+    if(spiCookie->isFullDuplex()) {
+        return HasReturnvaluesIF::RETURN_OK;
+    }
+
+    return performHalfDuplexReception(spiCookie);
+}
+
+
+ReturnValue_t SpiComIF::performHalfDuplexReception(SpiCookie* spiCookie) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    std::string device = spiCookie->getSpiDevice();
+    int fileDescriptor = 0;
+    UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR,
+            "SpiComIF::requestReceiveMessage");
+    if(fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
+        return OPENING_FILE_FAILED;
+    }
+
+    uint8_t* rxBuf = nullptr;
+    size_t readSize = spiCookie->getCurrentTransferSize();
+    result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    gpioId_t gpioId = spiCookie->getChipSelectPin();
+    if(gpioId != gpio::NO_GPIO) {
+        result = spiMutex->lockMutex(timeoutType, timeoutMs);
+        if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::getSendSuccess: Failed to lock mutex" << std::endl;
+#endif
+            return result;
+        }
+        gpioComIF->pullLow(gpioId);
+    }
+
+    if(read(fileDescriptor, rxBuf, readSize) != static_cast<ssize_t>(readSize)) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpiComIF::sendMessage: Half-Duplex read operation failed!" << std::endl;
+#else
+        sif::printWarning("SpiComIF::sendMessage: Half-Duplex read operation failed!\n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+        result = HALF_DUPLEX_TRANSFER_FAILED;
+    }
+
+    if(gpioId != gpio::NO_GPIO) {
+        gpioComIF->pullHigh(gpioId);
+        result = spiMutex->unlockMutex();
+        if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::getSendSuccess: Failed to unlock mutex" << std::endl;
+#endif
+            return result;
+        }
+    }
+
+    return result;
+}
+
+ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    uint8_t* rxBuf = nullptr;
+    ReturnValue_t result = getReadBuffer(spiCookie->getSpiAddress(), &rxBuf);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+
+    *buffer = rxBuf;
+    *size = spiCookie->getCurrentTransferSize();
+    spiCookie->setTransferSize(0);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+MutexIF* SpiComIF::getMutex(MutexIF::TimeoutType* timeoutType, uint32_t* timeoutMs) {
+    if(timeoutType != nullptr) {
+        *timeoutType = this->timeoutType;
+    }
+    if(timeoutMs != nullptr) {
+        *timeoutMs = this->timeoutMs;
+    }
+    return spiMutex;
+}
+
+void SpiComIF::performSpiWiretapping(SpiCookie* spiCookie) {
+    if(spiCookie == nullptr) {
+        return;
+    }
+    size_t dataLen = spiCookie->getTransferStructHandle()->len;
+    uint8_t* dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->tx_buf);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "Sent SPI data: " << std::endl;
+    arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
+    sif::info << "Received SPI data: " << std::endl;
+#else
+    sif::printInfo("Sent SPI data: \n");
+    arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
+    sif::printInfo("Received SPI data: \n");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    dataPtr = reinterpret_cast<uint8_t*>(spiCookie->getTransferStructHandle()->rx_buf);
+    arrayprinter::print(dataPtr, dataLen, OutputType::HEX, false);
+}
+
+ReturnValue_t SpiComIF::getReadBuffer(address_t spiAddress, uint8_t** buffer) {
+    if(buffer == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    auto iter = spiDeviceMap.find(spiAddress);
+    if(iter == spiDeviceMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    *buffer = iter->second.replyBuffer.data();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+GpioIF* SpiComIF::getGpioInterface() {
+    return gpioComIF;
+}
+
+void SpiComIF::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed) {
+    int retval = ioctl(spiFd, SPI_IOC_WR_MODE, reinterpret_cast<uint8_t*>(&mode));
+    if(retval != 0) {
+        utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI mode failed");
+    }
+
+    retval = ioctl(spiFd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
+    if(retval != 0) {
+        utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
+    }
+}

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

@@ -0,0 +1,91 @@
+#ifndef LINUX_SPI_SPICOMIF_H_
+#define LINUX_SPI_SPICOMIF_H_
+
+#include "fsfw/FSFW.h"
+#include "spiDefinitions.h"
+#include "returnvalues/classIds.h"
+#include "fsfw_hal/common/gpio/GpioIF.h"
+
+#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+
+#include <vector>
+#include <unordered_map>
+
+class SpiCookie;
+
+/**
+ * @brief   Encapsulates access to linux SPI driver for FSFW objects
+ * @details
+ * Right now, only full-duplex SPI is supported. Most device specific transfer properties
+ * are contained in the SPI cookie.
+ * @author  R. Mueller
+ */
+class SpiComIF: public DeviceCommunicationIF, public SystemObject {
+public:
+    static constexpr uint8_t spiRetvalId = CLASS_ID::HAL_SPI;
+    static constexpr ReturnValue_t OPENING_FILE_FAILED =
+            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 0);
+    /* Full duplex (ioctl) transfer failure */
+    static constexpr ReturnValue_t FULL_DUPLEX_TRANSFER_FAILED =
+            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 1);
+    /* Half duplex (read/write) transfer failure */
+    static constexpr ReturnValue_t HALF_DUPLEX_TRANSFER_FAILED =
+            HasReturnvaluesIF::makeReturnCode(spiRetvalId, 2);
+
+    SpiComIF(object_id_t objectId, GpioIF* gpioComIF);
+
+    ReturnValue_t initializeInterface(CookieIF * cookie) override;
+    ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
+            size_t sendLen) override;
+    ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+    ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+            size_t requestLen) override;
+    ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+            size_t *size) override;
+
+    /**
+     * @brief   This function returns the mutex which can be used to protect the spi bus when
+     *          the chip select must be driven from outside of the com if.
+     */
+    MutexIF* getMutex(MutexIF::TimeoutType* timeoutType = nullptr, uint32_t* timeoutMs = nullptr);
+
+    /**
+     * Perform a regular send operation using Linux iotcl. This is public so it can be used
+     * in functions like a user callback if special handling is only necessary for certain commands.
+     * @param spiCookie
+     * @param sendData
+     * @param sendLen
+     * @return
+     */
+    ReturnValue_t performRegularSendOperation(SpiCookie* spiCookie, const uint8_t *sendData,
+            size_t sendLen);
+
+    GpioIF* getGpioInterface();
+    void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
+    void performSpiWiretapping(SpiCookie* spiCookie);
+
+    ReturnValue_t getReadBuffer(address_t spiAddress, uint8_t** buffer);
+
+private:
+
+    struct SpiInstance {
+        SpiInstance(size_t maxRecvSize): replyBuffer(std::vector<uint8_t>(maxRecvSize)) {}
+        std::vector<uint8_t> replyBuffer;
+    };
+
+    GpioIF* gpioComIF = nullptr;
+
+    MutexIF* spiMutex = nullptr;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t timeoutMs = 20;
+
+    using SpiDeviceMap = std::unordered_map<address_t, SpiInstance>;
+    using SpiDeviceMapIter = SpiDeviceMap::iterator;
+
+    SpiDeviceMap spiDeviceMap;
+
+    ReturnValue_t performHalfDuplexReception(SpiCookie* spiCookie);
+};
+
+#endif /* LINUX_SPI_SPICOMIF_H_ */

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

@@ -0,0 +1,144 @@
+#include "fsfw_hal/linux/spi/SpiCookie.h"
+
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
+        const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed):
+        SpiCookie(spi::SpiComIfModes::REGULAR, spiAddress, chipSelect, spiDev, maxSize, spiMode,
+                spiSpeed, nullptr, nullptr) {
+
+}
+
+SpiCookie::SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxSize,
+        spi::SpiModes spiMode, uint32_t spiSpeed):
+                SpiCookie(spiAddress, gpio::NO_GPIO, spiDev, maxSize, spiMode, spiSpeed) {
+}
+
+SpiCookie::SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
+        const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+        spi::send_callback_function_t callback, void *args):
+		        SpiCookie(spi::SpiComIfModes::CALLBACK, spiAddress, chipSelect, spiDev, maxSize,
+		                spiMode, spiSpeed, callback, args) {
+}
+
+SpiCookie::SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
+        std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+        spi::send_callback_function_t callback, void* args):
+                spiAddress(spiAddress), chipSelectPin(chipSelect), spiDevice(spiDev),
+                comIfMode(comIfMode), maxSize(maxSize), spiMode(spiMode), spiSpeed(spiSpeed),
+                sendCallback(callback), callbackArgs(args) {
+}
+
+spi::SpiComIfModes SpiCookie::getComIfMode() const {
+    return this->comIfMode;
+}
+
+void SpiCookie::getSpiParameters(spi::SpiModes& spiMode, uint32_t& spiSpeed,
+        UncommonParameters* parameters) const {
+    spiMode = this->spiMode;
+    spiSpeed = this->spiSpeed;
+
+    if(parameters != nullptr) {
+        parameters->threeWireSpi = uncommonParameters.threeWireSpi;
+        parameters->lsbFirst = uncommonParameters.lsbFirst;
+        parameters->noCs = uncommonParameters.noCs;
+        parameters->bitsPerWord = uncommonParameters.bitsPerWord;
+        parameters->csHigh = uncommonParameters.csHigh;
+    }
+}
+
+gpioId_t SpiCookie::getChipSelectPin() const {
+    return chipSelectPin;
+}
+
+size_t SpiCookie::getMaxBufferSize() const {
+    return maxSize;
+}
+
+address_t SpiCookie::getSpiAddress() const {
+    return spiAddress;
+}
+
+std::string SpiCookie::getSpiDevice() const {
+    return spiDevice;
+}
+
+void SpiCookie::setThreeWireSpi(bool enable) {
+    uncommonParameters.threeWireSpi = enable;
+}
+
+void SpiCookie::setLsbFirst(bool enable) {
+    uncommonParameters.lsbFirst = enable;
+}
+
+void SpiCookie::setNoCs(bool enable) {
+    uncommonParameters.noCs = enable;
+}
+
+void SpiCookie::setBitsPerWord(uint8_t bitsPerWord) {
+    uncommonParameters.bitsPerWord = bitsPerWord;
+}
+
+void SpiCookie::setCsHigh(bool enable) {
+    uncommonParameters.csHigh = enable;
+}
+
+void SpiCookie::activateCsDeselect(bool deselectCs, uint16_t delayUsecs) {
+    spiTransferStruct.cs_change = deselectCs;
+    spiTransferStruct.delay_usecs = delayUsecs;
+}
+
+void SpiCookie::assignReadBuffer(uint8_t* rx) {
+    if(rx != nullptr) {
+        spiTransferStruct.rx_buf = reinterpret_cast<__u64>(rx);
+    }
+}
+
+void SpiCookie::assignWriteBuffer(const uint8_t* tx) {
+    if(tx != nullptr) {
+        spiTransferStruct.tx_buf = reinterpret_cast<__u64>(tx);
+    }
+}
+
+void SpiCookie::setCallbackMode(spi::send_callback_function_t callback,
+        void *args) {
+    this->comIfMode = spi::SpiComIfModes::CALLBACK;
+    this->sendCallback = callback;
+    this->callbackArgs = args;
+}
+
+void SpiCookie::setCallbackArgs(void *args) {
+    this->callbackArgs = args;
+}
+
+spi_ioc_transfer* SpiCookie::getTransferStructHandle() {
+    return &spiTransferStruct;
+}
+
+void SpiCookie::setFullOrHalfDuplex(bool halfDuplex) {
+    this->halfDuplex = halfDuplex;
+}
+
+bool SpiCookie::isFullDuplex() const {
+    return not this->halfDuplex;
+}
+
+void SpiCookie::setTransferSize(size_t transferSize) {
+    spiTransferStruct.len = transferSize;
+}
+
+size_t SpiCookie::getCurrentTransferSize() const {
+    return spiTransferStruct.len;
+}
+
+void SpiCookie::setSpiSpeed(uint32_t newSpeed) {
+    this->spiSpeed = newSpeed;
+}
+
+void SpiCookie::setSpiMode(spi::SpiModes newMode) {
+    this->spiMode = newMode;
+}
+
+void SpiCookie::getCallback(spi::send_callback_function_t *callback,
+        void **args) {
+    *callback = this->sendCallback;
+    *args = this->callbackArgs;
+}

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

@@ -0,0 +1,183 @@
+#ifndef LINUX_SPI_SPICOOKIE_H_
+#define LINUX_SPI_SPICOOKIE_H_
+
+#include "spiDefinitions.h"
+#include "../../common/gpio/gpioDefinitions.h"
+
+#include <fsfw/devicehandlers/CookieIF.h>
+
+#include <linux/spi/spidev.h>
+
+/**
+ * @brief   This cookie class is passed to the SPI communication interface
+ * @details
+ * This cookie contains device specific properties like speed and SPI mode or the SPI transfer
+ * struct required by the Linux SPI driver. It also contains a handle to a GPIO interface
+ * to perform slave select switching when necessary.
+ *
+ * The user can specify gpio::NO_GPIO as the GPIO ID or use a custom send callback to meet
+ * special requirements like expander slave select switching (e.g. GPIO or I2C expander)
+ * or special timing related requirements.
+ */
+class SpiCookie: public CookieIF {
+public:
+    /**
+     * Each SPI device will have a corresponding cookie. The cookie is used by the communication
+     * interface and contains device specific information like the largest expected size to be
+     * sent and received and the GPIO pin used to toggle the SPI slave select pin.
+     * @param spiAddress
+     * @param chipSelect    Chip select. gpio::NO_GPIO can be used for hardware slave selects.
+     * @param spiDev
+     * @param maxSize
+     */
+    SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev,
+            const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed);
+
+    /**
+     * Like constructor above, but without a dedicated GPIO CS. Can be used for hardware
+     * slave select or if CS logic is performed with decoders.
+     */
+    SpiCookie(address_t spiAddress, std::string spiDev, const size_t maxReplySize,
+            spi::SpiModes spiMode, uint32_t spiSpeed);
+
+    /**
+     * Use the callback mode of the SPI communication interface. The user can pass the callback
+     * function here or by using the setter function #setCallbackMode
+     */
+    SpiCookie(address_t spiAddress, gpioId_t chipSelect, std::string spiDev, const size_t maxSize,
+            spi::SpiModes spiMode, uint32_t spiSpeed, spi::send_callback_function_t callback,
+            void *args);
+
+    /**
+     * Get the callback function
+     * @param callback
+     * @param args
+     */
+    void getCallback(spi::send_callback_function_t* callback, void** args);
+
+    address_t getSpiAddress() const;
+    std::string getSpiDevice() const;
+    gpioId_t getChipSelectPin() const;
+    size_t getMaxBufferSize() const;
+
+    spi::SpiComIfModes getComIfMode() const;
+
+    /** Enables changing SPI speed at run-time */
+    void setSpiSpeed(uint32_t newSpeed);
+    /** Enables changing the SPI mode at run-time */
+    void setSpiMode(spi::SpiModes newMode);
+
+    /**
+     * Set the SPI to callback mode and assigns the user supplied callback and an argument
+     * passed to the callback.
+     * @param callback
+     * @param args
+     */
+    void setCallbackMode(spi::send_callback_function_t callback, void* args);
+
+    /**
+	 * Can be used to set the callback arguments and a later point than initialization.
+	 * @param args
+	 */
+	void setCallbackArgs(void* args);
+
+    /**
+     * True if SPI transfers should be performed in full duplex mode
+     * @return
+     */
+    bool isFullDuplex() const;
+
+    /**
+     * Set transfer type to full duplex or half duplex. Full duplex is the default setting,
+     * ressembling common SPI hardware implementation with shift registers, where read and writes
+     * happen simultaneosly.
+     * @param fullDuplex
+     */
+    void setFullOrHalfDuplex(bool halfDuplex);
+
+    /**
+     * This needs to be called to specify where the SPI driver writes to or reads from.
+     * @param readLocation
+     * @param writeLocation
+     */
+    void assignReadBuffer(uint8_t* rx);
+    void assignWriteBuffer(const uint8_t* tx);
+    /**
+     * Set size for the next transfer. Set to 0 for no transfer
+     * @param transferSize
+     */
+    void setTransferSize(size_t transferSize);
+    size_t getCurrentTransferSize() const;
+
+    struct UncommonParameters {
+        uint8_t bitsPerWord = 8;
+        bool noCs = false;
+        bool csHigh = false;
+        bool threeWireSpi = false;
+        /* MSB first is more common */
+        bool lsbFirst = false;
+    };
+
+    /**
+     * Can be used to explicitely disable hardware chip select.
+     * Some drivers like the Raspberry Pi Linux driver will not use hardware chip select by default
+     * (see https://www.raspberrypi.org/documentation/hardware/raspberrypi/spi/README.md)
+     * @param enable
+     */
+    void setNoCs(bool enable);
+    void setThreeWireSpi(bool enable);
+    void setLsbFirst(bool enable);
+    void setCsHigh(bool enable);
+    void setBitsPerWord(uint8_t bitsPerWord);
+
+    void getSpiParameters(spi::SpiModes& spiMode, uint32_t& spiSpeed,
+            UncommonParameters* parameters = nullptr) const;
+
+    /**
+     * See spidev.h cs_change and delay_usecs
+     * @param deselectCs
+     * @param delayUsecs
+     */
+    void activateCsDeselect(bool deselectCs, uint16_t delayUsecs);
+
+    spi_ioc_transfer* getTransferStructHandle();
+private:
+
+    /**
+     * Internal constructor which initializes every field
+     * @param spiAddress
+     * @param chipSelect
+     * @param spiDev
+     * @param maxSize
+     * @param spiMode
+     * @param spiSpeed
+     * @param callback
+     * @param args
+     */
+    SpiCookie(spi::SpiComIfModes comIfMode, address_t spiAddress, gpioId_t chipSelect,
+            std::string spiDev, const size_t maxSize, spi::SpiModes spiMode, uint32_t spiSpeed,
+            spi::send_callback_function_t callback, void* args);
+
+    address_t spiAddress;
+    gpioId_t chipSelectPin;
+    std::string spiDevice;
+
+    spi::SpiComIfModes comIfMode;
+
+    // Required for regular mode
+    const size_t maxSize;
+    spi::SpiModes spiMode;
+    uint32_t spiSpeed;
+    bool halfDuplex = false;
+
+    // Required for callback mode
+    spi::send_callback_function_t sendCallback = nullptr;
+    void* callbackArgs = nullptr;
+
+    struct spi_ioc_transfer spiTransferStruct = {};
+    UncommonParameters uncommonParameters;
+};
+
+
+
+#endif /* LINUX_SPI_SPICOOKIE_H_ */

hal/src/fsfw_hal/linux/spi/spiDefinitions.h

@@ -0,0 +1,28 @@
+#ifndef LINUX_SPI_SPIDEFINITONS_H_
+#define LINUX_SPI_SPIDEFINITONS_H_
+
+#include "../../common/gpio/gpioDefinitions.h"
+#include "../../common/spi/spiCommon.h"
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include <linux/spi/spidev.h>
+
+#include <cstdint>
+
+class SpiCookie;
+class SpiComIF;
+
+namespace spi {
+
+enum SpiComIfModes {
+	REGULAR,
+	CALLBACK
+};
+
+
+using send_callback_function_t = ReturnValue_t (*) (SpiComIF* comIf, SpiCookie *cookie,
+        const uint8_t *sendData, size_t sendLen, void* args);
+
+}
+
+#endif /* LINUX_SPI_SPIDEFINITONS_H_ */

hal/src/fsfw_hal/linux/uart/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} PUBLIC
+	UartComIF.cpp
+	UartCookie.cpp
+)

hal/src/fsfw_hal/linux/uart/UartComIF.cpp

@@ -0,0 +1,529 @@
+#include "UartComIF.h"
+#include "OBSWConfig.h"
+
+#include "fsfw_hal/linux/utility.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+#include <cstring>
+#include <fcntl.h>
+#include <errno.h>
+#include <termios.h>
+#include <unistd.h>
+
+UartComIF::UartComIF(object_id_t objectId): SystemObject(objectId){
+}
+
+UartComIF::~UartComIF() {}
+
+ReturnValue_t UartComIF::initializeInterface(CookieIF* cookie) {
+
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+
+    if(cookie == nullptr) {
+        return NULLPOINTER;
+    }
+
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if (uartCookie == nullptr) {
+        sif::error << "UartComIF::initializeInterface: Invalid UART Cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    deviceFile = uartCookie->getDeviceFile();
+
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter == uartDeviceMap.end()) {
+        int fileDescriptor = configureUartPort(uartCookie);
+        if (fileDescriptor < 0) {
+            return RETURN_FAILED;
+        }
+        size_t maxReplyLen = uartCookie->getMaxReplyLen();
+        UartElements uartElements = {fileDescriptor, std::vector<uint8_t>(maxReplyLen), 0};
+        auto status = uartDeviceMap.emplace(deviceFile, uartElements);
+        if (status.second == false) {
+            sif::warning << "UartComIF::initializeInterface: Failed to insert device " <<
+                    deviceFile << "to UART device map" << std::endl;
+            return RETURN_FAILED;
+        }
+    }
+    else {
+        sif::warning << "UartComIF::initializeInterface: UART device " << deviceFile <<
+                " already in use" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    return RETURN_OK;
+}
+
+int UartComIF::configureUartPort(UartCookie* uartCookie) {
+
+    struct termios options = {};
+
+    std::string deviceFile = uartCookie->getDeviceFile();
+    int flags = O_RDWR;
+    if(uartCookie->getUartMode() == UartModes::CANONICAL) {
+        // In non-canonical mode, don't specify O_NONBLOCK because these properties will be
+        // controlled by the VTIME and VMIN parameters and O_NONBLOCK would override this
+        flags |= O_NONBLOCK;
+    }
+    int fd = open(deviceFile.c_str(), flags);
+
+    if (fd < 0) {
+        sif::warning << "UartComIF::configureUartPort: Failed to open uart " << deviceFile <<
+                "with error code " << errno << strerror(errno) << std::endl;
+        return fd;
+    }
+
+    /* Read in existing settings */
+    if(tcgetattr(fd, &options) != 0) {
+        sif::warning << "UartComIF::configureUartPort: Error " << errno << "from tcgetattr: "
+                << strerror(errno) << std::endl;
+        return fd;
+    }
+
+    setParityOptions(&options, uartCookie);
+    setStopBitOptions(&options, uartCookie);
+    setDatasizeOptions(&options, uartCookie);
+    setFixedOptions(&options);
+    setUartMode(&options, *uartCookie);
+    if(uartCookie->getInputShouldBeFlushed()) {
+        tcflush(fd, TCIFLUSH);
+    }
+
+    /* Sets uart to non-blocking mode. Read returns immediately when there are no data available */
+    options.c_cc[VTIME] = 0;
+    options.c_cc[VMIN] = 0;
+
+    configureBaudrate(&options, uartCookie);
+
+    /* Save option settings */
+    if (tcsetattr(fd, TCSANOW, &options) != 0) {
+        sif::warning << "UartComIF::configureUartPort: Failed to set options with error " <<
+                errno << ": " << strerror(errno);
+        return fd;
+    }
+    return fd;
+}
+
+void UartComIF::setParityOptions(struct termios* options, UartCookie* uartCookie) {
+    /* Clear parity bit */
+    options->c_cflag &= ~PARENB;
+    switch (uartCookie->getParity()) {
+    case Parity::EVEN:
+        options->c_cflag |= PARENB;
+        options->c_cflag &= ~PARODD;
+        break;
+    case Parity::ODD:
+        options->c_cflag |= PARENB;
+        options->c_cflag |= PARODD;
+        break;
+    default:
+        break;
+    }
+}
+
+void UartComIF::setStopBitOptions(struct termios* options, UartCookie* uartCookie) {
+    /* Clear stop field. Sets stop bit to one bit */
+    options->c_cflag &= ~CSTOPB;
+    switch (uartCookie->getStopBits()) {
+    case StopBits::TWO_STOP_BITS:
+        options->c_cflag |= CSTOPB;
+        break;
+    default:
+        break;
+    }
+}
+
+void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCookie) {
+    /* Clear size bits */
+    options->c_cflag &= ~CSIZE;
+    switch (uartCookie->getBitsPerWord()) {
+    case 5:
+        options->c_cflag |= CS5;
+        break;
+    case 6:
+        options->c_cflag |= CS6;
+        break;
+    case 7:
+        options->c_cflag |= CS7;
+        break;
+    case 8:
+        options->c_cflag |= CS8;
+        break;
+    default:
+        sif::warning << "UartComIF::setDatasizeOptions: Invalid size specified" << std::endl;
+        break;
+    }
+}
+
+void UartComIF::setFixedOptions(struct termios* options) {
+    /* Disable RTS/CTS hardware flow control */
+    options->c_cflag &= ~CRTSCTS;
+    /* Turn on READ & ignore ctrl lines (CLOCAL = 1) */
+    options->c_cflag |= CREAD | CLOCAL;
+    /* Disable echo */
+    options->c_lflag &= ~ECHO;
+    /* Disable erasure */
+    options->c_lflag &= ~ECHOE;
+    /* Disable new-line echo */
+    options->c_lflag &= ~ECHONL;
+    /* Disable interpretation of INTR, QUIT and SUSP */
+    options->c_lflag &= ~ISIG;
+    /* Turn off s/w flow ctrl */
+    options->c_iflag &= ~(IXON | IXOFF | IXANY);
+    /* Disable any special handling of received bytes */
+    options->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL);
+    /* Prevent special interpretation of output bytes (e.g. newline chars) */
+    options->c_oflag &= ~OPOST;
+    /* Prevent conversion of newline to carriage return/line feed */
+    options->c_oflag &= ~ONLCR;
+}
+
+void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCookie) {
+    switch (uartCookie->getBaudrate()) {
+    case 50:
+        cfsetispeed(options, B50);
+        cfsetospeed(options, B50);
+        break;
+    case 75:
+        cfsetispeed(options, B75);
+        cfsetospeed(options, B75);
+        break;
+    case 110:
+        cfsetispeed(options, B110);
+        cfsetospeed(options, B110);
+        break;
+    case 134:
+        cfsetispeed(options, B134);
+        cfsetospeed(options, B134);
+        break;
+    case 150:
+        cfsetispeed(options, B150);
+        cfsetospeed(options, B150);
+        break;
+    case 200:
+        cfsetispeed(options, B200);
+        cfsetospeed(options, B200);
+        break;
+    case 300:
+        cfsetispeed(options, B300);
+        cfsetospeed(options, B300);
+        break;
+    case 600:
+        cfsetispeed(options, B600);
+        cfsetospeed(options, B600);
+        break;
+    case 1200:
+        cfsetispeed(options, B1200);
+        cfsetospeed(options, B1200);
+        break;
+    case 1800:
+        cfsetispeed(options, B1800);
+        cfsetospeed(options, B1800);
+        break;
+    case 2400:
+        cfsetispeed(options, B2400);
+        cfsetospeed(options, B2400);
+        break;
+    case 4800:
+        cfsetispeed(options, B4800);
+        cfsetospeed(options, B4800);
+        break;
+    case 9600:
+        cfsetispeed(options, B9600);
+        cfsetospeed(options, B9600);
+        break;
+    case 19200:
+        cfsetispeed(options, B19200);
+        cfsetospeed(options, B19200);
+        break;
+    case 38400:
+        cfsetispeed(options, B38400);
+        cfsetospeed(options, B38400);
+        break;
+    case 57600:
+        cfsetispeed(options, B57600);
+        cfsetospeed(options, B57600);
+        break;
+    case 115200:
+        cfsetispeed(options, B115200);
+        cfsetospeed(options, B115200);
+        break;
+    case 230400:
+        cfsetispeed(options, B230400);
+        cfsetospeed(options, B230400);
+        break;
+    case 460800:
+        cfsetispeed(options, B460800);
+        cfsetospeed(options, B460800);
+        break;
+    default:
+        sif::warning << "UartComIF::configureBaudrate: Baudrate not supported" << std::endl;
+        break;
+    }
+}
+
+ReturnValue_t UartComIF::sendMessage(CookieIF *cookie,
+        const uint8_t *sendData, size_t sendLen) {
+    int fd = 0;
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+
+    if(sendLen == 0) {
+        return RETURN_OK;
+    }
+
+    if(sendData == nullptr) {
+        sif::warning << "UartComIF::sendMessage: Send data is nullptr" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::sendMessasge: Invalid UART Cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if (uartDeviceMapIter == uartDeviceMap.end()) {
+        sif::debug << "UartComIF::sendMessage: Device file " << deviceFile <<
+                "not in UART map" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    fd = uartDeviceMapIter->second.fileDescriptor;
+
+    if (write(fd, sendData, sendLen) != (int)sendLen) {
+        sif::error << "UartComIF::sendMessage: Failed to send data with error code " <<
+                errno << ": Error description: " << strerror(errno) << std::endl;
+        return RETURN_FAILED;
+    }
+
+    return RETURN_OK;
+}
+
+ReturnValue_t UartComIF::getSendSuccess(CookieIF *cookie) {
+    return RETURN_OK;
+}
+
+ReturnValue_t UartComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::debug << "UartComIF::requestReceiveMessage: Invalid Uart Cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    UartModes uartMode = uartCookie->getUartMode();
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+
+    if(uartMode == UartModes::NON_CANONICAL and requestLen == 0) {
+        return RETURN_OK;
+    }
+
+    if (uartDeviceMapIter == uartDeviceMap.end()) {
+        sif::debug << "UartComIF::requestReceiveMessage: Device file " << deviceFile
+                << " not in uart map" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    if (uartMode == UartModes::CANONICAL) {
+        return handleCanonicalRead(*uartCookie, uartDeviceMapIter, requestLen);
+    }
+    else if (uartMode == UartModes::NON_CANONICAL) {
+        return handleNoncanonicalRead(*uartCookie, uartDeviceMapIter, requestLen);
+    }
+    else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+}
+
+ReturnValue_t UartComIF::handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+        size_t requestLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    uint8_t maxReadCycles = uartCookie.getReadCycles();
+    uint8_t currentReadCycles = 0;
+    int bytesRead = 0;
+    size_t currentBytesRead = 0;
+    size_t maxReplySize = uartCookie.getMaxReplyLen();
+    int fd = iter->second.fileDescriptor;
+    auto bufferPtr = iter->second.replyBuffer.data();
+    iter->second.replyLen = 0;
+    do {
+        size_t allowedReadSize = 0;
+        if(currentBytesRead >= maxReplySize) {
+            // Overflow risk. Emit warning, trigger event and break. If this happens,
+            // the reception buffer is not large enough or data is not polled often enough.
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::warning << "UartComIF::requestReceiveMessage: Next read would cause overflow!"
+                    << std::endl;
+#else
+            sif::printWarning("UartComIF::requestReceiveMessage: "
+                    "Next read would cause overflow!");
+#endif
+#endif
+            result = UART_RX_BUFFER_TOO_SMALL;
+            break;
+        }
+        else {
+            allowedReadSize = maxReplySize - currentBytesRead;
+        }
+
+        bytesRead = read(fd, bufferPtr, allowedReadSize);
+        if (bytesRead < 0) {
+            // EAGAIN: No data available in non-blocking mode
+            if(errno != EAGAIN) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+                sif::warning << "UartComIF::handleCanonicalRead: read failed with code" <<
+                        errno << ": " << strerror(errno) << std::endl;
+#else
+                sif::printWarning("UartComIF::handleCanonicalRead: read failed with code %d: %s\n",
+                        errno, strerror(errno));
+#endif
+#endif
+                return RETURN_FAILED;
+            }
+
+        }
+        else if(bytesRead > 0) {
+            iter->second.replyLen += bytesRead;
+            bufferPtr += bytesRead;
+            currentBytesRead += bytesRead;
+        }
+        currentReadCycles++;
+    } while(bytesRead > 0 and currentReadCycles < maxReadCycles);
+    return result;
+}
+
+ReturnValue_t UartComIF::handleNoncanonicalRead(UartCookie &uartCookie, UartDeviceMapIter &iter,
+        size_t requestLen) {
+    int fd = iter->second.fileDescriptor;
+    auto bufferPtr = iter->second.replyBuffer.data();
+    // Size check to prevent buffer overflow
+    if(requestLen > uartCookie.getMaxReplyLen()) {
+#if OBSW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "UartComIF::requestReceiveMessage: Next read would cause overflow!"
+                << std::endl;
+#else
+        sif::printWarning("UartComIF::requestReceiveMessage: "
+                "Next read would cause overflow!");
+#endif
+#endif
+        return UART_RX_BUFFER_TOO_SMALL;
+    }
+    int bytesRead = read(fd, bufferPtr, requestLen);
+    if (bytesRead < 0) {
+        return RETURN_FAILED;
+    }
+    else if (bytesRead != static_cast<int>(requestLen)) {
+        if(uartCookie.isReplySizeFixed()) {
+            sif::warning << "UartComIF::requestReceiveMessage: Only read " << bytesRead <<
+                    " of " << requestLen << " bytes" << std::endl;
+            return RETURN_FAILED;
+        }
+    }
+    iter->second.replyLen = bytesRead;
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t UartComIF::readReceivedMessage(CookieIF *cookie,
+        uint8_t **buffer, size_t* size) {
+
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::debug << "UartComIF::readReceivedMessage: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if (uartDeviceMapIter == uartDeviceMap.end()) {
+        sif::debug << "UartComIF::readReceivedMessage: Device file " << deviceFile <<
+                " not in uart map" << std::endl;
+        return RETURN_FAILED;
+    }
+
+    *buffer = uartDeviceMapIter->second.replyBuffer.data();
+    *size = uartDeviceMapIter->second.replyLen;
+
+    /* Length is reset to 0 to prevent reading the same data twice */
+    uartDeviceMapIter->second.replyLen = 0;
+
+    return RETURN_OK;
+}
+
+ReturnValue_t UartComIF::flushUartRxBuffer(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartRxBuffer: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCIFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
+ReturnValue_t UartComIF::flushUartTxBuffer(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartTxBuffer: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCOFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
+ReturnValue_t UartComIF::flushUartTxAndRxBuf(CookieIF *cookie) {
+    std::string deviceFile;
+    UartDeviceMapIter uartDeviceMapIter;
+    UartCookie* uartCookie = dynamic_cast<UartCookie*>(cookie);
+    if(uartCookie == nullptr) {
+        sif::warning << "UartComIF::flushUartTxAndRxBuf: Invalid uart cookie!" << std::endl;
+        return NULLPOINTER;
+    }
+    deviceFile = uartCookie->getDeviceFile();
+    uartDeviceMapIter = uartDeviceMap.find(deviceFile);
+    if(uartDeviceMapIter != uartDeviceMap.end()) {
+        int fd = uartDeviceMapIter->second.fileDescriptor;
+        tcflush(fd, TCIOFLUSH);
+        return RETURN_OK;
+    }
+    return RETURN_FAILED;
+}
+
+void UartComIF::setUartMode(struct termios *options, UartCookie &uartCookie) {
+    UartModes uartMode = uartCookie.getUartMode();
+    if(uartMode == UartModes::NON_CANONICAL) {
+        /* Disable canonical mode */
+        options->c_lflag &= ~ICANON;
+    }
+    else if(uartMode == UartModes::CANONICAL) {
+        options->c_lflag |= ICANON;
+    }
+}

hal/src/fsfw_hal/linux/uart/UartComIF.h

@@ -0,0 +1,125 @@
+#ifndef BSP_Q7S_COMIF_UARTCOMIF_H_
+#define BSP_Q7S_COMIF_UARTCOMIF_H_
+
+#include "UartCookie.h"
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+
+#include <unordered_map>
+#include <vector>
+
+/**
+ * @brief 	This is the communication interface to access serial ports on linux based operating
+ *          systems.
+ *
+ * @details The implementation follows the instructions from https://blog.mbedded.ninja/programming/
+ *          operating-systems/linux/linux-serial-ports-using-c-cpp/#disabling-canonical-mode
+ *
+ * @author 	J. Meier
+ */
+class UartComIF: public DeviceCommunicationIF, public SystemObject {
+public:
+    static constexpr uint8_t uartRetvalId = CLASS_ID::HAL_UART;
+
+    static constexpr ReturnValue_t UART_READ_FAILURE =
+            HasReturnvaluesIF::makeReturnCode(uartRetvalId, 1);
+    static constexpr ReturnValue_t UART_READ_SIZE_MISSMATCH =
+            HasReturnvaluesIF::makeReturnCode(uartRetvalId, 2);
+    static constexpr ReturnValue_t UART_RX_BUFFER_TOO_SMALL =
+            HasReturnvaluesIF::makeReturnCode(uartRetvalId, 3);
+
+    UartComIF(object_id_t objectId);
+
+    virtual ~UartComIF();
+
+    ReturnValue_t initializeInterface(CookieIF * cookie) override;
+    ReturnValue_t sendMessage(CookieIF *cookie,const uint8_t *sendData,
+            size_t sendLen) override;
+    ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+    ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+            size_t requestLen) override;
+    ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+            size_t *size) override;
+
+    /**
+     * @brief   This function discards all data received but not read in the UART buffer.
+     */
+    ReturnValue_t flushUartRxBuffer(CookieIF *cookie);
+
+    /**
+     * @brief   This function discards all data in the transmit buffer of the UART driver.
+     */
+    ReturnValue_t flushUartTxBuffer(CookieIF *cookie);
+
+    /**
+     * @brief   This function discards both data in the transmit and receive buffer of the UART.
+     */
+    ReturnValue_t flushUartTxAndRxBuf(CookieIF *cookie);
+
+private:
+
+    using UartDeviceFile_t = std::string;
+
+    struct UartElements {
+        int fileDescriptor;
+        std::vector<uint8_t> replyBuffer;
+        /** Number of bytes read will be written to this variable */
+        size_t replyLen;
+    };
+
+    using UartDeviceMap = std::unordered_map<UartDeviceFile_t, UartElements>;
+    using UartDeviceMapIter = UartDeviceMap::iterator;
+
+    /**
+     * The uart devie map stores informations of initialized uart ports.
+     */
+    UartDeviceMap uartDeviceMap;
+
+    /**
+     * @brief	This function opens and configures a uart device by using the information stored
+     *          in the uart cookie.
+     * @param uartCookie    Pointer to uart cookie with information about the uart. Contains the
+     *                      uart device file, baudrate, parity, stopbits etc.
+     * @return  The file descriptor of the configured uart.
+     */
+    int configureUartPort(UartCookie* uartCookie);
+
+    /**
+     * @brief   This function adds the parity settings to the termios options struct.
+     *
+     * @param options   Pointer to termios options struct which will be modified to enable or disable
+     *                  parity checking.
+     * @param uartCookie    Pointer to uart cookie containing the information about the desired
+     *                      parity settings.
+     *
+     */
+    void setParityOptions(struct termios* options, UartCookie* uartCookie);
+
+    void setStopBitOptions(struct termios* options, UartCookie* uartCookie);
+
+    /**
+     * @brief   This function sets options which are not configurable by the uartCookie.
+     */
+    void setFixedOptions(struct termios* options);
+
+    /**
+     * @brief   With this function the datasize settings are added to the termios options struct.
+     */
+    void setDatasizeOptions(struct termios* options, UartCookie* uartCookie);
+
+    /**
+     * @brief   This functions adds the  baudrate specified in the uartCookie to the termios options
+     *          struct.
+     */
+    void configureBaudrate(struct termios* options, UartCookie* uartCookie);
+
+    void setUartMode(struct termios* options, UartCookie& uartCookie);
+
+    ReturnValue_t handleCanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+            size_t requestLen);
+    ReturnValue_t handleNoncanonicalRead(UartCookie& uartCookie, UartDeviceMapIter& iter,
+            size_t requestLen);
+
+};
+
+#endif /* BSP_Q7S_COMIF_UARTCOMIF_H_ */

hal/src/fsfw_hal/linux/uart/UartCookie.cpp

@@ -0,0 +1,97 @@
+#include "fsfw_hal/linux/uart/UartCookie.h"
+
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+        uint32_t baudrate, size_t maxReplyLen):
+        handlerId(handlerId), deviceFile(deviceFile), uartMode(uartMode),
+        baudrate(baudrate), maxReplyLen(maxReplyLen) {
+}
+
+UartCookie::~UartCookie() {}
+
+uint32_t UartCookie::getBaudrate() const {
+    return baudrate;
+}
+
+size_t UartCookie::getMaxReplyLen() const {
+    return maxReplyLen;
+}
+
+std::string UartCookie::getDeviceFile() const {
+    return deviceFile;
+}
+
+void UartCookie::setParityOdd() {
+    parity = Parity::ODD;
+}
+
+void UartCookie::setParityEven() {
+    parity = Parity::EVEN;
+}
+
+Parity UartCookie::getParity() const {
+    return parity;
+}
+
+void UartCookie::setBitsPerWord(uint8_t bitsPerWord_) {
+    switch(bitsPerWord_) {
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+        break;
+    default:
+        sif::debug << "UartCookie::setBitsPerWord: Invalid bits per word specified" << std::endl;
+        return;
+    }
+    bitsPerWord = bitsPerWord_;
+}
+
+uint8_t UartCookie::getBitsPerWord() const {
+    return bitsPerWord;
+}
+
+StopBits UartCookie::getStopBits() const {
+    return stopBits;
+}
+
+void UartCookie::setTwoStopBits() {
+    stopBits = StopBits::TWO_STOP_BITS;
+}
+
+void UartCookie::setOneStopBit() {
+    stopBits = StopBits::ONE_STOP_BIT;
+}
+
+UartModes UartCookie::getUartMode() const {
+    return uartMode;
+}
+
+void UartCookie::setReadCycles(uint8_t readCycles) {
+    this->readCycles = readCycles;
+}
+
+void UartCookie::setToFlushInput(bool enable) {
+    this->flushInput = enable;
+}
+
+uint8_t UartCookie::getReadCycles() const {
+    return readCycles;
+}
+
+bool UartCookie::getInputShouldBeFlushed() {
+    return this->flushInput;
+}
+
+object_id_t UartCookie::getHandlerId() const {
+    return this->handlerId;
+}
+
+void UartCookie::setNoFixedSizeReply() {
+    replySizeFixed = false;
+}
+
+bool UartCookie::isReplySizeFixed() {
+    return replySizeFixed;
+}

hal/src/fsfw_hal/linux/uart/UartCookie.h

@@ -0,0 +1,121 @@
+#ifndef SAM9G20_COMIF_COOKIES_UART_COOKIE_H_
+#define SAM9G20_COMIF_COOKIES_UART_COOKIE_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/objectmanager/SystemObjectIF.h>
+
+#include <string>
+
+enum class Parity {
+    NONE,
+    EVEN,
+    ODD
+};
+
+enum class StopBits {
+    ONE_STOP_BIT,
+    TWO_STOP_BITS
+};
+
+enum class UartModes {
+    CANONICAL,
+    NON_CANONICAL
+};
+
+/**
+ * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
+ *          The constructor only requests for common options like the baudrate. Other options can
+ *          be set by member functions.
+ *
+ * @author 	J. Meier
+ */
+class UartCookie: public CookieIF {
+public:
+
+    /**
+     * @brief	Constructor for the uart cookie.
+     * @param deviceFile    The device file specifying the uart to use, e.g. "/dev/ttyPS1"
+     * @param uartMode      Specify the UART mode. The canonical mode should be used if the
+     *                      messages are separated by a delimited character like '\n'. See the
+     *                      termios documentation for more information
+     * @param baudrate      The baudrate to use for input and output. Possible Baudrates are: 50,
+     *                      75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, B19200,
+     *                      38400, 57600, 115200, 230400, 460800
+     * @param maxReplyLen   The maximum size an object using this cookie expects
+     * @details
+     * Default configuration: No parity
+     *                        8 databits (number of bits transfered with one uart frame)
+     *                        One stop bit
+     */
+    UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+            uint32_t baudrate, size_t maxReplyLen);
+
+    virtual ~UartCookie();
+
+    uint32_t getBaudrate() const;
+    size_t getMaxReplyLen() const;
+    std::string getDeviceFile() const;
+    Parity getParity() const;
+    uint8_t getBitsPerWord() const;
+    StopBits getStopBits() const;
+    UartModes getUartMode() const;
+    object_id_t getHandlerId() const;
+
+    /**
+     * The UART ComIF will only perform a specified number of read cycles for the canonical mode.
+     * The user can specify how many of those read cycles are performed for one device handler
+     * communication cycle. An example use-case would be to read all available GPS NMEA strings
+     * at once.
+     * @param readCycles
+     */
+    void setReadCycles(uint8_t readCycles);
+    uint8_t getReadCycles() const;
+
+    /**
+     * Allows to flush the data which was received but has not been read yet. This is useful
+     * to discard obsolete data at software startup.
+     */
+    void setToFlushInput(bool enable);
+    bool getInputShouldBeFlushed();
+
+    /**
+     * Functions two enable parity checking.
+     */
+    void setParityOdd();
+    void setParityEven();
+
+    /**
+     * Function two set number of bits per UART frame.
+     */
+    void setBitsPerWord(uint8_t bitsPerWord_);
+
+    /**
+     * Function to specify the number of stopbits.
+     */
+    void setTwoStopBits();
+    void setOneStopBit();
+
+    /**
+     * Calling this function prevents the UartComIF to return failed if not all requested bytes
+     * could be read. This is required by a device handler when the size of a reply is not known.
+     */
+    void setNoFixedSizeReply();
+
+    bool isReplySizeFixed();
+
+private:
+
+    const object_id_t handlerId;
+    std::string deviceFile;
+    const UartModes uartMode;
+    bool flushInput = false;
+    uint32_t baudrate;
+    size_t maxReplyLen = 0;
+    Parity parity = Parity::NONE;
+    uint8_t bitsPerWord = 8;
+    uint8_t readCycles = 1;
+    StopBits stopBits = StopBits::ONE_STOP_BIT;
+    bool replySizeFixed = true;
+};
+
+#endif

hal/src/fsfw_hal/linux/utility.cpp

@@ -0,0 +1,26 @@
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw_hal/linux/utility.h"
+
+#include <cerrno>
+#include <cstring>
+
+void utility::handleIoctlError(const char* const customPrintout) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    if(customPrintout != nullptr) {
+        sif::warning << customPrintout << std::endl;
+    }
+    sif::warning << "handleIoctlError: Error code " << errno << ", "<< strerror(errno) <<
+            std::endl;
+#else
+    if(customPrintout != nullptr) {
+        sif::printWarning("%s\n", customPrintout);
+    }
+    sif::printWarning("handleIoctlError: Error code %d, %s\n", errno, strerror(errno));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+
+}
+
+

hal/src/fsfw_hal/linux/utility.h

@@ -0,0 +1,10 @@
+#ifndef LINUX_UTILITY_UTILITY_H_
+#define LINUX_UTILITY_UTILITY_H_
+
+namespace utility {
+
+void handleIoctlError(const char* const customPrintout);
+
+}
+
+#endif /* LINUX_UTILITY_UTILITY_H_ */

hal/src/fsfw_hal/stm32h7/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_subdirectory(spi)
+add_subdirectory(gpio)
+add_subdirectory(devicetest)
+
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    dma.cpp
+)

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

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

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

@@ -0,0 +1,558 @@
+#include "fsfw_hal/stm32h7/devicetest/GyroL3GD20H.h"
+
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
+
+#include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+#include "stm32h7xx_hal_spi.h"
+#include "stm32h7xx_hal_rcc.h"
+
+#include <cstring>
+
+alignas(32) std::array<uint8_t, GyroL3GD20H::recvBufferSize> GyroL3GD20H::rxBuffer;
+alignas(32) std::array<uint8_t, GyroL3GD20H::txBufferSize>
+GyroL3GD20H::txBuffer __attribute__((section(".dma_buffer")));
+
+TransferStates transferState = TransferStates::IDLE;
+spi::TransferModes  GyroL3GD20H::transferMode = spi::TransferModes::POLLING;
+
+
+GyroL3GD20H::GyroL3GD20H(SPI_HandleTypeDef *spiHandle, spi::TransferModes transferMode_):
+        spiHandle(spiHandle) {
+    txDmaHandle = new DMA_HandleTypeDef();
+    rxDmaHandle = new DMA_HandleTypeDef();
+    spi::setSpiHandle(spiHandle);
+    spi::assignSpiUserArgs(spi::SpiBus::SPI_1, spiHandle);
+    transferMode = transferMode_;
+    if(transferMode == spi::TransferModes::DMA) {
+        mspCfg = new spi::MspDmaConfigStruct();
+        auto typedCfg = dynamic_cast<spi::MspDmaConfigStruct*>(mspCfg);
+        spi::setDmaHandles(txDmaHandle, rxDmaHandle);
+        spi::h743zi::standardDmaCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS,
+                IrqPriorities::HIGHEST_FREERTOS, IrqPriorities::HIGHEST_FREERTOS);
+        spi::setSpiDmaMspFunctions(typedCfg);
+    }
+    else if(transferMode == spi::TransferModes::INTERRUPT) {
+        mspCfg = new spi::MspIrqConfigStruct();
+        auto typedCfg = dynamic_cast<spi::MspIrqConfigStruct*>(mspCfg);
+        spi::h743zi::standardInterruptCfg(*typedCfg, IrqPriorities::HIGHEST_FREERTOS);
+        spi::setSpiIrqMspFunctions(typedCfg);
+    }
+    else if(transferMode == spi::TransferModes::POLLING) {
+        mspCfg = new spi::MspPollingConfigStruct();
+        auto typedCfg = dynamic_cast<spi::MspPollingConfigStruct*>(mspCfg);
+        spi::h743zi::standardPollingCfg(*typedCfg);
+        spi::setSpiPollingMspFunctions(typedCfg);
+    }
+
+    spi::assignTransferRxTxCompleteCallback(&spiTransferCompleteCallback, nullptr);
+    spi::assignTransferErrorCallback(&spiTransferErrorCallback, nullptr);
+
+    GPIO_InitTypeDef chipSelect = {};
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+    chipSelect.Pin = GPIO_PIN_14;
+    chipSelect.Mode = GPIO_MODE_OUTPUT_PP;
+    HAL_GPIO_Init(GPIOD, &chipSelect);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+}
+
+GyroL3GD20H::~GyroL3GD20H() {
+    delete txDmaHandle;
+    delete rxDmaHandle;
+    if(mspCfg != nullptr) {
+        delete mspCfg;
+    }
+}
+
+ReturnValue_t GyroL3GD20H::initialize() {
+    // Configure the SPI peripheral
+    spiHandle->Instance               = SPI1;
+    spiHandle->Init.BaudRatePrescaler = spi::getPrescaler(HAL_RCC_GetHCLKFreq(), 3900000);
+    spiHandle->Init.Direction         = SPI_DIRECTION_2LINES;
+    spi::assignSpiMode(spi::SpiModes::MODE_3, *spiHandle);
+    spiHandle->Init.DataSize          = SPI_DATASIZE_8BIT;
+    spiHandle->Init.FirstBit          = SPI_FIRSTBIT_MSB;
+    spiHandle->Init.TIMode            = SPI_TIMODE_DISABLE;
+    spiHandle->Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
+    spiHandle->Init.CRCPolynomial     = 7;
+    spiHandle->Init.CRCLength         = SPI_CRC_LENGTH_8BIT;
+    spiHandle->Init.NSS               = SPI_NSS_SOFT;
+    spiHandle->Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;
+    // Recommended setting to avoid glitches
+    spiHandle->Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
+    spiHandle->Init.Mode = SPI_MODE_MASTER;
+    if(HAL_SPI_Init(spiHandle) != HAL_OK) {
+        sif::printWarning("Error initializing SPI\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    delete mspCfg;
+    transferState = TransferStates::WAIT;
+
+    sif::printInfo("GyroL3GD20H::performOperation: Reading WHO AM I register\n");
+
+    txBuffer[0] = WHO_AM_I_REG | STM_READ_MASK;
+    txBuffer[1] = 0;
+
+    switch(transferMode)  {
+    case(spi::TransferModes::DMA): {
+        return handleDmaTransferInit();
+    }
+    case(spi::TransferModes::INTERRUPT): {
+        return handleInterruptTransferInit();
+    }
+    case(spi::TransferModes::POLLING): {
+        return handlePollingTransferInit();
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::performOperation() {
+    switch(transferMode)  {
+    case(spi::TransferModes::DMA): {
+        return handleDmaSensorRead();
+    }
+    case(spi::TransferModes::POLLING): {
+        return handlePollingSensorRead();
+    }
+    case(spi::TransferModes::INTERRUPT): {
+        return handleInterruptSensorRead();
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::handleDmaTransferInit() {
+    /* Clean D-cache */
+    /* Make sure the address is 32-byte aligned and add 32-bytes to length,
+    in case it overlaps cacheline */
+    // See https://community.st.com/s/article/FAQ-DMA-is-not-working-on-STM32H7-devices
+    HAL_StatusTypeDef result = performDmaTransfer(2);
+    if(result != HAL_OK) {
+        // Transfer error in transmission process
+        sif::printWarning("GyroL3GD20H::initialize: Error transmitting SPI with DMA\n");
+    }
+
+    // Wait for the transfer to complete
+    while (transferState == TransferStates::WAIT) {
+        TaskFactory::delayTask(1);
+    }
+
+    switch(transferState) {
+    case(TransferStates::SUCCESS): {
+        uint8_t whoAmIVal = rxBuffer[1];
+        if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) {
+            sif::printDebug("GyroL3GD20H::initialize: "
+                    "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal);
+        }
+        transferState = TransferStates::IDLE;
+        break;
+    }
+    case(TransferStates::FAILURE): {
+        sif::printWarning("Transfer failure\n");
+        transferState = TransferStates::FAILURE;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    sif::printInfo("GyroL3GD20H::initialize: Configuring device\n");
+    // Configure the 5 configuration registers
+    uint8_t configRegs[5];
+    prepareConfigRegs(configRegs);
+
+    result = performDmaTransfer(6);
+    if(result != HAL_OK) {
+        // Transfer error in transmission process
+        sif::printWarning("Error transmitting SPI with DMA\n");
+    }
+
+    // Wait for the transfer to complete
+    while (transferState == TransferStates::WAIT) {
+        TaskFactory::delayTask(1);
+    }
+
+    switch(transferState) {
+    case(TransferStates::SUCCESS): {
+        sif::printInfo("GyroL3GD20H::initialize: Configuration transfer success\n");
+        transferState = TransferStates::IDLE;
+        break;
+    }
+    case(TransferStates::FAILURE): {
+        sif::printWarning("GyroL3GD20H::initialize: Configuration transfer failure\n");
+        transferState = TransferStates::FAILURE;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 5);
+    result = performDmaTransfer(6);
+    if(result != HAL_OK) {
+        // Transfer error in transmission process
+        sif::printWarning("Error transmitting SPI with DMA\n");
+    }
+    // Wait for the transfer to complete
+    while (transferState == TransferStates::WAIT) {
+        TaskFactory::delayTask(1);
+    }
+
+    switch(transferState) {
+    case(TransferStates::SUCCESS): {
+        if(rxBuffer[1] != configRegs[0] or rxBuffer[2] != configRegs[1] or
+                rxBuffer[3] != configRegs[2] or rxBuffer[4] != configRegs[3] or
+                rxBuffer[5] != configRegs[4]) {
+            sif::printWarning("GyroL3GD20H::initialize: Configuration failure\n");
+        }
+        else {
+            sif::printInfo("GyroL3GD20H::initialize: Configuration success\n");
+        }
+        transferState = TransferStates::IDLE;
+        break;
+    }
+    case(TransferStates::FAILURE): {
+        sif::printWarning("GyroL3GD20H::initialize: Configuration transfer failure\n");
+        transferState = TransferStates::FAILURE;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::handleDmaSensorRead() {
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 14);
+
+    HAL_StatusTypeDef result = performDmaTransfer(15);
+    if(result != HAL_OK) {
+        // Transfer error in transmission process
+        sif::printDebug("GyroL3GD20H::handleDmaSensorRead: Error transmitting SPI with DMA\n");
+    }
+    // Wait for the transfer to complete
+    while (transferState == TransferStates::WAIT) {
+        TaskFactory::delayTask(1);
+    }
+
+    switch(transferState) {
+    case(TransferStates::SUCCESS): {
+        handleSensorReadout();
+        break;
+    }
+    case(TransferStates::FAILURE): {
+        sif::printWarning("GyroL3GD20H::handleDmaSensorRead: Sensor read failure\n");
+        transferState = TransferStates::FAILURE;
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+HAL_StatusTypeDef GyroL3GD20H::performDmaTransfer(size_t sendSize) {
+    transferState = TransferStates::WAIT;
+#if STM_USE_PERIPHERAL_TX_BUFFER_MPU_PROTECTION == 0
+    SCB_CleanDCache_by_Addr((uint32_t*)(((uint32_t)txBuffer.data()) & ~(uint32_t)0x1F),
+            txBuffer.size()+32);
+#endif
+
+    // Start SPI transfer via DMA
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    return HAL_SPI_TransmitReceive_DMA(spiHandle, txBuffer.data(), rxBuffer.data(), sendSize);
+}
+
+ReturnValue_t GyroL3GD20H::handlePollingTransferInit() {
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    auto result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 2, 1000);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+    switch(result) {
+    case(HAL_OK): {
+        sif::printInfo("GyroL3GD20H::initialize: Polling transfer success\n");
+        uint8_t whoAmIVal = rxBuffer[1];
+        if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) {
+            sif::printDebug("GyroL3GD20H::performOperation: "
+                    "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal);
+        }
+        break;
+    }
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    case(HAL_ERROR): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    sif::printInfo("GyroL3GD20H::initialize: Configuring device\n");
+    // Configure the 5 configuration registers
+    uint8_t configRegs[5];
+    prepareConfigRegs(configRegs);
+
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 6, 1000);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+    switch(result) {
+    case(HAL_OK): {
+        break;
+    }
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    case(HAL_ERROR): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 5);
+
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 6, 1000);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+    switch(result) {
+    case(HAL_OK): {
+        if(rxBuffer[1] != configRegs[0] or rxBuffer[2] != configRegs[1] or
+                rxBuffer[3] != configRegs[2] or rxBuffer[4] != configRegs[3] or
+                rxBuffer[5] != configRegs[4]) {
+            sif::printWarning("GyroL3GD20H::initialize: Configuration failure\n");
+        }
+        else {
+            sif::printInfo("GyroL3GD20H::initialize: Configuration success\n");
+        }
+        break;
+    }
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    case(HAL_ERROR): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::handlePollingSensorRead() {
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 14);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    auto result = HAL_SPI_TransmitReceive(spiHandle, txBuffer.data(), rxBuffer.data(), 15, 1000);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+
+    switch(result) {
+    case(HAL_OK): {
+        handleSensorReadout();
+        break;
+    }
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer timeout\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    case(HAL_ERROR): {
+        sif::printDebug("GyroL3GD20H::initialize: Polling transfer failure\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::handleInterruptTransferInit() {
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 2)) {
+    case(HAL_OK): {
+        sif::printInfo("GyroL3GD20H::initialize: Interrupt transfer success\n");
+        // Wait for the transfer to complete
+        while (transferState == TransferStates::WAIT) {
+            TaskFactory::delayTask(1);
+        }
+
+        uint8_t whoAmIVal = rxBuffer[1];
+        if(whoAmIVal != EXPECTED_WHO_AM_I_VAL) {
+            sif::printDebug("GyroL3GD20H::initialize: "
+                    "Read WHO AM I value %d not equal to expected value!\n", whoAmIVal);
+        }
+        break;
+    }
+    case(HAL_BUSY):
+    case(HAL_ERROR):
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    sif::printInfo("GyroL3GD20H::initialize: Configuring device\n");
+    transferState = TransferStates::WAIT;
+    // Configure the 5 configuration registers
+    uint8_t configRegs[5];
+    prepareConfigRegs(configRegs);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 6)) {
+    case(HAL_OK): {
+        // Wait for the transfer to complete
+        while (transferState == TransferStates::WAIT) {
+            TaskFactory::delayTask(1);
+        }
+        break;
+    }
+    case(HAL_BUSY):
+    case(HAL_ERROR):
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 5);
+    transferState = TransferStates::WAIT;
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 6)) {
+    case(HAL_OK): {
+        // Wait for the transfer to complete
+        while (transferState == TransferStates::WAIT) {
+            TaskFactory::delayTask(1);
+        }
+        if(rxBuffer[1] != configRegs[0] or rxBuffer[2] != configRegs[1] or
+                rxBuffer[3] != configRegs[2] or rxBuffer[4] != configRegs[3] or
+                rxBuffer[5] != configRegs[4]) {
+            sif::printWarning("GyroL3GD20H::initialize: Configuration failure\n");
+        }
+        else {
+            sif::printInfo("GyroL3GD20H::initialize: Configuration success\n");
+        }
+        break;
+    }
+    case(HAL_BUSY):
+    case(HAL_ERROR):
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Initialization failure using interrupts\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t GyroL3GD20H::handleInterruptSensorRead() {
+    transferState = TransferStates::WAIT;
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK | STM_READ_MASK;
+    std::memset(txBuffer.data() + 1, 0 , 14);
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    switch(HAL_SPI_TransmitReceive_IT(spiHandle, txBuffer.data(), rxBuffer.data(), 15)) {
+    case(HAL_OK): {
+        // Wait for the transfer to complete
+        while (transferState == TransferStates::WAIT) {
+            TaskFactory::delayTask(1);
+        }
+        handleSensorReadout();
+        break;
+    }
+    case(HAL_BUSY):
+    case(HAL_ERROR):
+    case(HAL_TIMEOUT): {
+        sif::printDebug("GyroL3GD20H::initialize: Sensor read failure using interrupts\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void GyroL3GD20H::prepareConfigRegs(uint8_t* configRegs) {
+    // Enable sensor
+    configRegs[0] = 0b00001111;
+    configRegs[1] = 0b00000000;
+    configRegs[2] = 0b00000000;
+    // Big endian select
+    configRegs[3] = 0b01000000;
+    configRegs[4] = 0b00000000;
+
+    txBuffer[0] = CTRL_REG_1 | STM_AUTO_INCREMENT_MASK;
+    std::memcpy(txBuffer.data() + 1, configRegs, 5);
+}
+
+uint8_t GyroL3GD20H::readRegPolling(uint8_t reg) {
+    uint8_t rxBuf[2] = {};
+    uint8_t txBuf[2] = {};
+    txBuf[0] = reg | STM_READ_MASK;
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
+    auto result = HAL_SPI_TransmitReceive(spiHandle, txBuf, rxBuf, 2, 1000);
+    if(result) {};
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+    return rxBuf[1];
+}
+
+void GyroL3GD20H::handleSensorReadout() {
+    uint8_t statusReg = rxBuffer[8];
+    int16_t gyroXRaw = rxBuffer[9] << 8 | rxBuffer[10];
+    float gyroX = static_cast<float>(gyroXRaw) * 0.00875;
+    int16_t gyroYRaw = rxBuffer[11] << 8 | rxBuffer[12];
+    float gyroY =  static_cast<float>(gyroYRaw) * 0.00875;
+    int16_t gyroZRaw = rxBuffer[13] << 8 | rxBuffer[14];
+    float gyroZ =  static_cast<float>(gyroZRaw) * 0.00875;
+    sif::printInfo("Status register: 0b" BYTE_TO_BINARY_PATTERN "\n", BYTE_TO_BINARY(statusReg));
+    sif::printInfo("Gyro X: %f\n", gyroX);
+    sif::printInfo("Gyro Y: %f\n", gyroY);
+    sif::printInfo("Gyro Z: %f\n", gyroZ);
+}
+
+
+void GyroL3GD20H::spiTransferCompleteCallback(SPI_HandleTypeDef *hspi, void* args) {
+    transferState = TransferStates::SUCCESS;
+    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
+    if(GyroL3GD20H::transferMode == spi::TransferModes::DMA) {
+        // Invalidate cache prior to access by CPU
+        SCB_InvalidateDCache_by_Addr ((uint32_t *)GyroL3GD20H::rxBuffer.data(),
+                GyroL3GD20H::recvBufferSize);
+    }
+}
+
+/**
+ * @brief  SPI error callbacks.
+ * @param  hspi: SPI handle
+ * @note   This example shows a simple way to report transfer error, and you can
+ *         add your own implementation.
+ * @retval None
+ */
+void GyroL3GD20H::spiTransferErrorCallback(SPI_HandleTypeDef *hspi, void* args) {
+    transferState = TransferStates::FAILURE;
+}

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

@@ -0,0 +1,70 @@
+#ifndef FSFW_HAL_STM32H7_DEVICETEST_GYRO_L3GD20H_H_
+#define FSFW_HAL_STM32H7_DEVICETEST_GYRO_L3GD20H_H_
+
+#include "stm32h7xx_hal.h"
+#include "stm32h7xx_hal_spi.h"
+#include "../spi/mspInit.h"
+#include "../spi/spiDefinitions.h"
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+#include <cstdint>
+#include <array>
+
+enum class TransferStates {
+    IDLE,
+    WAIT,
+    SUCCESS,
+    FAILURE
+};
+
+class GyroL3GD20H {
+public:
+    GyroL3GD20H(SPI_HandleTypeDef* spiHandle, spi::TransferModes transferMode);
+    ~GyroL3GD20H();
+
+    ReturnValue_t initialize();
+    ReturnValue_t performOperation();
+
+private:
+
+    const uint8_t WHO_AM_I_REG = 0b00001111;
+    const uint8_t STM_READ_MASK = 0b10000000;
+    const uint8_t STM_AUTO_INCREMENT_MASK = 0b01000000;
+    const uint8_t EXPECTED_WHO_AM_I_VAL = 0b11010111;
+    const uint8_t CTRL_REG_1 = 0b00100000;
+    const uint32_t L3G_RANGE = 245;
+
+    SPI_HandleTypeDef* spiHandle;
+
+    static spi::TransferModes transferMode;
+    static constexpr size_t recvBufferSize = 32 * 10;
+    static std::array<uint8_t, recvBufferSize> rxBuffer;
+    static constexpr size_t txBufferSize = 32;
+    static std::array<uint8_t, txBufferSize> txBuffer;
+
+    ReturnValue_t handleDmaTransferInit();
+    ReturnValue_t handlePollingTransferInit();
+    ReturnValue_t handleInterruptTransferInit();
+
+    ReturnValue_t handleDmaSensorRead();
+    HAL_StatusTypeDef performDmaTransfer(size_t sendSize);
+    ReturnValue_t handlePollingSensorRead();
+    ReturnValue_t handleInterruptSensorRead();
+
+    uint8_t readRegPolling(uint8_t reg);
+
+    static void spiTransferCompleteCallback(SPI_HandleTypeDef *hspi, void* args);
+    static void spiTransferErrorCallback(SPI_HandleTypeDef *hspi, void* args);
+
+
+    void prepareConfigRegs(uint8_t* configRegs);
+    void handleSensorReadout();
+
+
+    DMA_HandleTypeDef* txDmaHandle = {};
+    DMA_HandleTypeDef* rxDmaHandle = {};
+    spi::MspCfgBase* mspCfg = {};
+};
+
+#endif /*  FSFW_HAL_STM32H7_DEVICETEST_GYRO_L3GD20H_H_ */

hal/src/fsfw_hal/stm32h7/dma.cpp

@@ -0,0 +1,84 @@
+#include <fsfw_hal/stm32h7/dma.h>
+
+#include <cstdint>
+#include <cstddef>
+
+user_handler_t DMA_1_USER_HANDLERS[8];
+user_args_t DMA_1_USER_ARGS[8];
+
+user_handler_t DMA_2_USER_HANDLERS[8];
+user_args_t DMA_2_USER_ARGS[8];
+
+void dma::assignDmaUserHandler(DMAIndexes dma_idx, DMAStreams stream_idx,
+        user_handler_t user_handler, user_args_t user_args) {
+    if(dma_idx == DMA_1) {
+        DMA_1_USER_HANDLERS[stream_idx] = user_handler;
+        DMA_1_USER_ARGS[stream_idx] = user_args;
+    }
+    else if(dma_idx == DMA_2) {
+        DMA_2_USER_HANDLERS[stream_idx] = user_handler;
+        DMA_2_USER_ARGS[stream_idx] = user_args;
+    }
+}
+
+// The interrupt handlers in the format required for the IRQ vector table
+
+/* Do not change these function names! They need to be exactly equal to the name of the functions
+defined in the startup_stm32h743xx.s files! */
+
+#define GENERIC_DMA_IRQ_HANDLER(DMA_IDX, STREAM_IDX) \
+    if(DMA_##DMA_IDX##_USER_HANDLERS[STREAM_IDX] != NULL) { \
+        DMA_##DMA_IDX##_USER_HANDLERS[STREAM_IDX](DMA_##DMA_IDX##_USER_ARGS[STREAM_IDX]); \
+        return; \
+    } \
+    Default_Handler() \
+
+extern"C" void DMA1_Stream0_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 0);
+}
+extern"C" void DMA1_Stream1_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 1);
+}
+extern"C" void DMA1_Stream2_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 2);
+}
+extern"C" void DMA1_Stream3_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 3);
+}
+extern"C" void DMA1_Stream4_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 4);
+}
+extern"C" void DMA1_Stream5_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 5);
+}
+extern"C" void DMA1_Stream6_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 6);
+}
+extern"C" void DMA1_Stream7_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(1, 7);
+}
+
+extern"C" void DMA2_Stream0_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 0);
+}
+extern"C" void DMA2_Stream1_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 1);
+}
+extern"C" void DMA2_Stream2_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 2);
+}
+extern"C" void DMA2_Stream3_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 3);
+}
+extern"C" void DMA2_Stream4_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 4);
+}
+extern"C" void DMA2_Stream5_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 5);
+}
+extern"C" void DMA2_Stream6_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 6);
+}
+extern"C" void DMA2_Stream7_IRQHandler() {
+    GENERIC_DMA_IRQ_HANDLER(2, 7);
+}

hal/src/fsfw_hal/stm32h7/dma.h

@@ -0,0 +1,49 @@
+#ifndef FSFW_HAL_STM32H7_DMA_H_
+#define FSFW_HAL_STM32H7_DMA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "interrupts.h"
+#include <cstdint>
+
+namespace dma {
+
+enum DMAType {
+    TX = 0,
+    RX = 1
+};
+
+enum DMAIndexes: uint8_t {
+    DMA_1 = 1,
+    DMA_2 = 2
+};
+
+enum DMAStreams {
+    STREAM_0 = 0,
+    STREAM_1 = 1,
+    STREAM_2 = 2,
+    STREAM_3 = 3,
+    STREAM_4 = 4,
+    STREAM_5 = 5,
+    STREAM_6 = 6,
+    STREAM_7 = 7,
+} ;
+
+/**
+ * Assign user interrupt handlers for DMA streams, allowing to pass an
+ * arbitrary argument as well. Generally, this argument will be the related DMA handle.
+ * @param user_handler
+ * @param user_args
+ */
+void assignDmaUserHandler(DMAIndexes dma_idx, DMAStreams stream_idx,
+        user_handler_t user_handler, user_args_t user_args);
+
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_HAL_STM32H7_DMA_H_ */

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

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

hal/src/fsfw_hal/stm32h7/gpio/gpio.cpp

@@ -0,0 +1,71 @@
+#include "fsfw_hal/stm32h7/gpio/gpio.h"
+
+#include "stm32h7xx_hal_rcc.h"
+
+void gpio::initializeGpioClock(GPIO_TypeDef* gpioPort) {
+#ifdef GPIOA
+    if(gpioPort == GPIOA) {
+        __HAL_RCC_GPIOA_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOB
+    if(gpioPort == GPIOB) {
+        __HAL_RCC_GPIOB_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOC
+    if(gpioPort == GPIOC) {
+        __HAL_RCC_GPIOC_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOD
+    if(gpioPort == GPIOD) {
+        __HAL_RCC_GPIOD_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOE
+    if(gpioPort == GPIOE) {
+        __HAL_RCC_GPIOE_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOF
+    if(gpioPort == GPIOF) {
+        __HAL_RCC_GPIOF_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOG
+    if(gpioPort == GPIOG) {
+        __HAL_RCC_GPIOG_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOH
+    if(gpioPort == GPIOH) {
+        __HAL_RCC_GPIOH_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOI
+    if(gpioPort == GPIOI) {
+        __HAL_RCC_GPIOI_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOJ
+    if(gpioPort == GPIOJ) {
+        __HAL_RCC_GPIOJ_CLK_ENABLE();
+    }
+#endif
+
+#ifdef GPIOK
+    if(gpioPort == GPIOK) {
+        __HAL_RCC_GPIOK_CLK_ENABLE();
+    }
+#endif
+}

hal/src/fsfw_hal/stm32h7/gpio/gpio.h

@@ -0,0 +1,12 @@
+#ifndef FSFW_HAL_STM32H7_GPIO_GPIO_H_
+#define FSFW_HAL_STM32H7_GPIO_GPIO_H_
+
+#include "stm32h7xx.h"
+
+namespace gpio {
+
+void initializeGpioClock(GPIO_TypeDef* gpioPort);
+
+}
+
+#endif /* FSFW_HAL_STM32H7_GPIO_GPIO_H_ */

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

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+)

hal/src/fsfw_hal/stm32h7/interrupts.h

@@ -0,0 +1,28 @@
+#ifndef FSFW_HAL_STM32H7_INTERRUPTS_H_
+#define FSFW_HAL_STM32H7_INTERRUPTS_H_
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Default handler which is defined in startup file as assembly code.
+ */
+extern void Default_Handler();
+
+typedef void (*user_handler_t) (void*);
+typedef void* user_args_t;
+
+enum IrqPriorities: uint8_t {
+    HIGHEST = 0,
+    HIGHEST_FREERTOS = 6,
+    LOWEST = 15
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_HAL_STM32H7_INTERRUPTS_H_ */

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

@@ -0,0 +1,9 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+    spiCore.cpp
+    spiDefinitions.cpp
+    spiInterrupts.cpp
+    mspInit.cpp
+    SpiCookie.cpp
+    SpiComIF.cpp
+    stm32h743ziSpi.cpp
+)

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

@@ -0,0 +1,468 @@
+#include "fsfw_hal/stm32h7/spi/SpiComIF.h"
+#include "fsfw_hal/stm32h7/spi/SpiCookie.h"
+
+#include "fsfw/tasks/SemaphoreFactory.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/gpio/gpio.h"
+
+// FreeRTOS required special Semaphore handling from an ISR. Therefore, we use the concrete
+// instance here, because RTEMS and FreeRTOS are the only relevant OSALs currently
+// and it is not trivial to add a releaseFromISR to the SemaphoreIF
+#if defined FSFW_OSAL_RTEMS
+#include "fsfw/osal/rtems/BinarySemaphore.h"
+#elif defined FSFW_OSAL_FREERTOS
+#include "fsfw/osal/freertos/TaskManagement.h"
+#include "fsfw/osal/freertos/BinarySemaphore.h"
+#endif
+
+#include "stm32h7xx_hal_gpio.h"
+
+SpiComIF::SpiComIF(object_id_t objectId): SystemObject(objectId) {
+    void* irqArgsVoided = reinterpret_cast<void*>(&irqArgs);
+    spi::assignTransferRxTxCompleteCallback(&spiTransferCompleteCallback, irqArgsVoided);
+    spi::assignTransferRxCompleteCallback(&spiTransferRxCompleteCallback, irqArgsVoided);
+    spi::assignTransferTxCompleteCallback(&spiTransferTxCompleteCallback, irqArgsVoided);
+    spi::assignTransferErrorCallback(&spiTransferErrorCallback, irqArgsVoided);
+}
+
+void SpiComIF::configureCacheMaintenanceOnTxBuffer(bool enable) {
+    this->cacheMaintenanceOnTxBuffer = enable;
+}
+
+void SpiComIF::addDmaHandles(DMA_HandleTypeDef *txHandle, DMA_HandleTypeDef *rxHandle) {
+    spi::setDmaHandles(txHandle, rxHandle);
+}
+
+ReturnValue_t SpiComIF::initialize() {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::initializeInterface(CookieIF *cookie) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error < "SpiComIF::initializeInterface: Invalid cookie" << std::endl;
+#else
+        sif::printError("SpiComIF::initializeInterface: Invalid cookie\n");
+#endif
+        return NULLPOINTER;
+    }
+    auto transferMode = spiCookie->getTransferMode();
+
+    if(transferMode == spi::TransferModes::DMA) {
+        DMA_HandleTypeDef *txHandle = nullptr;
+        DMA_HandleTypeDef *rxHandle = nullptr;
+        spi::getDmaHandles(&txHandle, &rxHandle);
+        if(txHandle == nullptr or rxHandle == nullptr) {
+            sif::printError("SpiComIF::initialize: DMA handles not set!\n");
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    // This semaphore ensures thread-safety for a given bus
+    spiSemaphore = dynamic_cast<BinarySemaphore*>(
+            SemaphoreFactory::instance()->createBinarySemaphore());
+    address_t spiAddress = spiCookie->getDeviceAddress();
+
+    auto iter = spiDeviceMap.find(spiAddress);
+    if(iter == spiDeviceMap.end()) {
+        size_t bufferSize = spiCookie->getMaxRecvSize();
+        auto statusPair = spiDeviceMap.emplace(spiAddress, SpiInstance(bufferSize));
+        if (not statusPair.second) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "SpiComIF::initializeInterface: Failed to insert device with address " <<
+                    spiAddress << "to SPI device map" << std::endl;
+#else
+            sif::printError("SpiComIF::initializeInterface: Failed to insert device with address "
+                    "%lu to SPI device map\n", static_cast<unsigned long>(spiAddress));
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif /* FSFW_VERBOSE_LEVEL >= 1 */
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    auto gpioPin = spiCookie->getChipSelectGpioPin();
+    auto gpioPort = spiCookie->getChipSelectGpioPort();
+
+    SPI_HandleTypeDef& spiHandle = spiCookie->getSpiHandle();
+
+    auto spiIdx = spiCookie->getSpiIdx();
+    if(spiIdx == spi::SpiBus::SPI_1) {
+#ifdef SPI1
+        spiHandle.Instance = SPI1;
+#endif
+    }
+    else if(spiIdx == spi::SpiBus::SPI_2) {
+#ifdef SPI2
+        spiHandle.Instance = SPI2;
+#endif
+    }
+    else {
+        printCfgError("SPI Bus Index");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+
+    auto mspCfg = spiCookie->getMspCfg();
+
+    if(transferMode == spi::TransferModes::POLLING) {
+        auto typedCfg = dynamic_cast<spi::MspPollingConfigStruct*>(mspCfg);
+        if(typedCfg == nullptr) {
+            printCfgError("Polling MSP");
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        spi::setSpiPollingMspFunctions(typedCfg);
+    }
+    else if(transferMode == spi::TransferModes::INTERRUPT) {
+        auto typedCfg = dynamic_cast<spi::MspIrqConfigStruct*>(mspCfg);
+        if(typedCfg == nullptr) {
+            printCfgError("IRQ MSP");
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        spi::setSpiIrqMspFunctions(typedCfg);
+    }
+    else if(transferMode == spi::TransferModes::DMA) {
+        auto typedCfg = dynamic_cast<spi::MspDmaConfigStruct*>(mspCfg);
+        if(typedCfg == nullptr) {
+            printCfgError("DMA MSP");
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        // Check DMA handles
+        DMA_HandleTypeDef* txHandle = nullptr;
+        DMA_HandleTypeDef* rxHandle = nullptr;
+        spi::getDmaHandles(&txHandle, &rxHandle);
+        if(txHandle == nullptr or rxHandle == nullptr) {
+            printCfgError("DMA Handle");
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        spi::setSpiDmaMspFunctions(typedCfg);
+    }
+
+    gpio::initializeGpioClock(gpioPort);
+    GPIO_InitTypeDef chipSelect = {};
+    chipSelect.Pin = gpioPin;
+    chipSelect.Mode = GPIO_MODE_OUTPUT_PP;
+    HAL_GPIO_Init(gpioPort, &chipSelect);
+    HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_SET);
+
+    if(HAL_SPI_Init(&spiHandle) != HAL_OK) {
+        sif::printWarning("SpiComIF::initialize: Error initializing SPI\n");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    // The MSP configuration struct is not required anymore
+    spiCookie->deleteMspCfg();
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+        return NULLPOINTER;
+    }
+
+    SPI_HandleTypeDef& spiHandle = spiCookie->getSpiHandle();
+
+    auto iter = spiDeviceMap.find(spiCookie->getDeviceAddress());
+    if(iter == spiDeviceMap.end()) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    iter->second.currentTransferLen = sendLen;
+
+    auto transferMode = spiCookie->getTransferMode();
+    switch(spiCookie->getTransferState()) {
+    case(spi::TransferStates::IDLE): {
+        break;
+    }
+    case(spi::TransferStates::WAIT):
+    case(spi::TransferStates::FAILURE):
+    case(spi::TransferStates::SUCCESS):
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    switch(transferMode) {
+    case(spi::TransferModes::POLLING): {
+        return handlePollingSendOperation(iter->second.replyBuffer.data(), spiHandle, *spiCookie,
+                sendData, sendLen);
+    }
+    case(spi::TransferModes::INTERRUPT): {
+        return handleInterruptSendOperation(iter->second.replyBuffer.data(), spiHandle, *spiCookie,
+                sendData, sendLen);
+    }
+    case(spi::TransferModes::DMA): {
+        return handleDmaSendOperation(iter->second.replyBuffer.data(), spiHandle, *spiCookie,
+                sendData, sendLen);
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::getSendSuccess(CookieIF *cookie) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+    SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+    if(spiCookie == nullptr) {
+        return NULLPOINTER;
+    }
+    switch(spiCookie->getTransferState()) {
+    case(spi::TransferStates::SUCCESS): {
+        auto iter = spiDeviceMap.find(spiCookie->getDeviceAddress());
+        if(iter == spiDeviceMap.end()) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *buffer = iter->second.replyBuffer.data();
+        *size = iter->second.currentTransferLen;
+        spiCookie->setTransferState(spi::TransferStates::IDLE);
+        break;
+    }
+    case(spi::TransferStates::FAILURE): {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpiComIF::readReceivedMessage: Transfer failure" << std::endl;
+#else
+        sif::printWarning("SpiComIF::readReceivedMessage: Transfer failure\n");
+#endif
+#endif
+        spiCookie->setTransferState(spi::TransferStates::IDLE);
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    case(spi::TransferStates::WAIT):
+    case(spi::TransferStates::IDLE): {
+        break;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SpiComIF::setDefaultPollingTimeout(dur_millis_t timeout) {
+    this->defaultPollingTimeout = timeout;
+}
+
+ReturnValue_t SpiComIF::handlePollingSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+        SpiCookie& spiCookie, const uint8_t *sendData, size_t sendLen) {
+    auto gpioPort = spiCookie.getChipSelectGpioPort();
+    auto gpioPin = spiCookie.getChipSelectGpioPin();
+    auto returnval = spiSemaphore->acquire(timeoutType, timeoutMs);
+    if(returnval != HasReturnvaluesIF::RETURN_OK) {
+        return returnval;
+    }
+    spiCookie.setTransferState(spi::TransferStates::WAIT);
+    HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_RESET);
+    auto result = HAL_SPI_TransmitReceive(&spiHandle, const_cast<uint8_t*>(sendData),
+            recvPtr, sendLen, defaultPollingTimeout);
+    HAL_GPIO_WritePin(gpioPort, gpioPin,  GPIO_PIN_SET);
+    spiSemaphore->release();
+    switch(result) {
+    case(HAL_OK): {
+        spiCookie.setTransferState(spi::TransferStates::SUCCESS);
+        break;
+    }
+    case(HAL_TIMEOUT): {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpiComIF::sendMessage: Polling Mode | Timeout for SPI device" <<
+                spiCookie->getDeviceAddress() << std::endl;
+#else
+        sif::printWarning("SpiComIF::sendMessage: Polling Mode | Timeout for SPI device %d\n",
+                spiCookie.getDeviceAddress());
+#endif
+#endif
+        spiCookie.setTransferState(spi::TransferStates::FAILURE);
+        return spi::HAL_TIMEOUT_RETVAL;
+    }
+    case(HAL_ERROR):
+    default: {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::warning << "SpiComIF::sendMessage: Polling Mode | HAL error for SPI device" <<
+                spiCookie->getDeviceAddress() << std::endl;
+#else
+        sif::printWarning("SpiComIF::sendMessage: Polling Mode | HAL error for SPI device %d\n",
+                spiCookie.getDeviceAddress());
+#endif
+#endif
+        spiCookie.setTransferState(spi::TransferStates::FAILURE);
+        return spi::HAL_ERROR_RETVAL;
+    }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SpiComIF::handleInterruptSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+        SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen) {
+    return handleIrqSendOperation(recvPtr, spiHandle, spiCookie, sendData, sendLen);
+}
+
+ReturnValue_t SpiComIF::handleDmaSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+        SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen) {
+    return handleIrqSendOperation(recvPtr, spiHandle, spiCookie, sendData, sendLen);
+}
+
+ReturnValue_t SpiComIF::handleIrqSendOperation(uint8_t *recvPtr, SPI_HandleTypeDef& spiHandle,
+        SpiCookie& spiCookie, const uint8_t *sendData, size_t sendLen) {
+    ReturnValue_t result = genericIrqSendSetup(recvPtr, spiHandle, spiCookie, sendData, sendLen);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    // yet another HAL driver which is not const-correct..
+    HAL_StatusTypeDef status = HAL_OK;
+    auto transferMode = spiCookie.getTransferMode();
+    if(transferMode == spi::TransferModes::DMA) {
+        if(cacheMaintenanceOnTxBuffer) {
+            /* Clean D-cache. Make sure the address is 32-byte aligned and add 32-bytes to length,
+            in case it overlaps cacheline */
+            SCB_CleanDCache_by_Addr((uint32_t*)(((uint32_t) sendData ) & ~(uint32_t)0x1F),
+                    sendLen + 32);
+        }
+        status = HAL_SPI_TransmitReceive_DMA(&spiHandle, const_cast<uint8_t*>(sendData),
+                currentRecvPtr, sendLen);
+    }
+    else {
+        status = HAL_SPI_TransmitReceive_IT(&spiHandle, const_cast<uint8_t*>(sendData),
+                currentRecvPtr, sendLen);
+    }
+    switch(status) {
+    case(HAL_OK): {
+        break;
+    }
+    default: {
+        return halErrorHandler(status, transferMode);
+    }
+    }
+    return result;
+}
+
+ReturnValue_t SpiComIF::halErrorHandler(HAL_StatusTypeDef status, spi::TransferModes transferMode) {
+    char modeString[10];
+    if(transferMode == spi::TransferModes::DMA) {
+        std::snprintf(modeString, sizeof(modeString), "Dma");
+    }
+    else {
+        std::snprintf(modeString, sizeof(modeString), "Interrupt");
+    }
+    sif::printWarning("SpiComIF::handle%sSendOperation: HAL error %d occured\n", modeString,
+            status);
+    switch(status) {
+    case(HAL_BUSY): {
+        return spi::HAL_BUSY_RETVAL;
+    }
+    case(HAL_ERROR): {
+        return spi::HAL_ERROR_RETVAL;
+    }
+    case(HAL_TIMEOUT): {
+        return spi::HAL_TIMEOUT_RETVAL;
+    }
+    default: {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    }
+}
+
+
+ReturnValue_t SpiComIF::genericIrqSendSetup(uint8_t *recvPtr, SPI_HandleTypeDef& spiHandle,
+        SpiCookie& spiCookie, const uint8_t *sendData, size_t sendLen) {
+    currentRecvPtr = recvPtr;
+    currentRecvBuffSize = sendLen;
+
+    // Take the semaphore which will be released by a callback when the transfer is complete
+    ReturnValue_t result = spiSemaphore->acquire(SemaphoreIF::TimeoutType::WAITING, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        // Configuration error
+        sif::printWarning("SpiComIF::handleInterruptSendOperation: Semaphore "
+                "could not be acquired after %d ms\n", timeoutMs);
+        return result;
+    }
+    // Cache the current SPI handle in any case
+    spi::setSpiHandle(&spiHandle);
+    // Assign the IRQ arguments for the user callbacks
+    irqArgs.comIF = this;
+    irqArgs.spiCookie = &spiCookie;
+    // The SPI handle is passed to the default SPI callback as a void argument. This callback
+    // is different from the user callbacks specified above!
+    spi::assignSpiUserArgs(spiCookie.getSpiIdx(), reinterpret_cast<void*>(&spiHandle));
+    HAL_GPIO_WritePin(spiCookie.getChipSelectGpioPort(), spiCookie.getChipSelectGpioPin(),
+            GPIO_PIN_RESET);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SpiComIF::spiTransferTxCompleteCallback(SPI_HandleTypeDef *hspi, void *args) {
+    genericIrqHandler(args, spi::TransferStates::SUCCESS);
+}
+
+void SpiComIF::spiTransferRxCompleteCallback(SPI_HandleTypeDef *hspi, void *args) {
+    genericIrqHandler(args, spi::TransferStates::SUCCESS);
+}
+
+void SpiComIF::spiTransferCompleteCallback(SPI_HandleTypeDef *hspi, void *args) {
+    genericIrqHandler(args, spi::TransferStates::SUCCESS);
+}
+
+void SpiComIF::spiTransferErrorCallback(SPI_HandleTypeDef *hspi, void *args) {
+    genericIrqHandler(args, spi::TransferStates::FAILURE);
+}
+
+void SpiComIF::genericIrqHandler(void *irqArgsVoid, spi::TransferStates targetState) {
+    IrqArgs* irqArgs = reinterpret_cast<IrqArgs*>(irqArgsVoid);
+    if(irqArgs == nullptr) {
+        return;
+    }
+    SpiCookie* spiCookie = irqArgs->spiCookie;
+    SpiComIF* comIF = irqArgs->comIF;
+    if(spiCookie == nullptr or comIF == nullptr) {
+        return;
+    }
+
+    spiCookie->setTransferState(targetState);
+
+    // Pull CS pin high again
+    HAL_GPIO_WritePin(spiCookie->getChipSelectGpioPort(), spiCookie->getChipSelectGpioPin(),
+            GPIO_PIN_SET);
+
+#if defined FSFW_OSAL_FREERTOS
+    // Release the task semaphore
+    BaseType_t taskWoken = pdFALSE;
+    ReturnValue_t result = BinarySemaphore::releaseFromISR(comIF->spiSemaphore->getSemaphore(),
+            &taskWoken);
+#elif defined FSFW_OSAL_RTEMS
+    ReturnValue_t result = comIF->spiSemaphore->release();
+#endif
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        // Configuration error
+        printf("SpiComIF::genericIrqHandler: Failure releasing Semaphore!\n");
+    }
+
+    // Perform cache maintenance operation for DMA transfers
+    if(spiCookie->getTransferMode() == spi::TransferModes::DMA) {
+        // Invalidate cache prior to access by CPU
+        SCB_InvalidateDCache_by_Addr ((uint32_t *) comIF->currentRecvPtr,
+                comIF->currentRecvBuffSize);
+    }
+#if defined FSFW_OSAL_FREERTOS
+    /* Request a context switch if the SPI ComIF task was woken up and has a higher priority
+    than the currently running task */
+    if(taskWoken == pdTRUE) {
+        TaskManagement::requestContextSwitch(CallContext::ISR);
+    }
+#endif
+}
+
+void SpiComIF::printCfgError(const char *const type) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "SpiComIF::initializeInterface: Invalid " << type << " configuration"
+            << std::endl;
+#else
+    sif::printWarning("SpiComIF::initializeInterface: Invalid %s configuration\n", type);
+#endif
+}

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

@@ -0,0 +1,130 @@
+#ifndef FSFW_HAL_STM32H7_SPI_SPICOMIF_H_
+#define FSFW_HAL_STM32H7_SPI_SPICOMIF_H_
+
+#include "fsfw/tasks/SemaphoreIF.h"
+#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+#include "stm32h7xx_hal_spi.h"
+#include "stm32h743xx.h"
+
+#include <vector>
+#include <map>
+
+class SpiCookie;
+class BinarySemaphore;
+
+/**
+ * @brief   This communication interface allows using generic device handlers with using
+ *          the STM32H7 SPI peripherals
+ * @details
+ * This communication interface supports all three major communcation modes:
+ *  - Polling: Simple, but not recommended to real use-cases, blocks the CPU
+ *  - Interrupt: Good for small data only arriving occasionally
+ *  - DMA: Good for large data which also occur regularly. Please note that the number
+ *    of DMA channels in limited
+ * The device specific information is usually kept in the SpiCookie class. The current
+ * implementation limits the transfer mode for a given SPI bus.
+ * @author  R. Mueller
+ */
+class SpiComIF:
+        public SystemObject,
+        public DeviceCommunicationIF {
+public:
+    /**
+     * Create a SPI communication interface for the given SPI peripheral (spiInstance)
+     * @param objectId
+     * @param spiInstance
+     * @param spiHandle
+     * @param transferMode
+     */
+    SpiComIF(object_id_t objectId);
+
+    /**
+     * Allows the user to disable cache maintenance on the TX buffer. This can be done if the
+     * TX buffers are places and MPU protected properly like specified in this link:
+     * https://community.st.com/s/article/FAQ-DMA-is-not-working-on-STM32H7-devices
+     * The cache maintenace is enabled by default.
+     * @param enable
+     */
+    void configureCacheMaintenanceOnTxBuffer(bool enable);
+
+    void setDefaultPollingTimeout(dur_millis_t timeout);
+
+    /**
+     * Add the DMA handles. These need to be set in the DMA transfer mode is used.
+     * @param txHandle
+     * @param rxHandle
+     */
+    void addDmaHandles(DMA_HandleTypeDef* txHandle, DMA_HandleTypeDef* rxHandle);
+
+    ReturnValue_t initialize() override;
+protected:
+
+    // DeviceCommunicationIF overrides
+    virtual ReturnValue_t initializeInterface(CookieIF * cookie) override;
+    virtual ReturnValue_t sendMessage(CookieIF *cookie,
+            const uint8_t * sendData, size_t sendLen) override;
+    virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+    virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie,
+            size_t requestLen) override;
+    virtual ReturnValue_t readReceivedMessage(CookieIF *cookie,
+            uint8_t **buffer, size_t *size) override;
+
+private:
+
+    struct SpiInstance {
+        SpiInstance(size_t maxRecvSize): replyBuffer(std::vector<uint8_t>(maxRecvSize)) {}
+        std::vector<uint8_t> replyBuffer;
+        size_t currentTransferLen = 0;
+    };
+
+    struct IrqArgs {
+        SpiComIF* comIF = nullptr;
+        SpiCookie* spiCookie = nullptr;
+    };
+
+    IrqArgs irqArgs;
+
+    uint32_t defaultPollingTimeout = 50;
+
+    SemaphoreIF::TimeoutType timeoutType = SemaphoreIF::TimeoutType::WAITING;
+    dur_millis_t timeoutMs = 20;
+
+    BinarySemaphore* spiSemaphore = nullptr;
+    bool cacheMaintenanceOnTxBuffer = true;
+
+    using SpiDeviceMap = std::map<address_t, SpiInstance>;
+    using SpiDeviceMapIter = SpiDeviceMap::iterator;
+
+    uint8_t* currentRecvPtr = nullptr;
+    size_t currentRecvBuffSize = 0;
+
+    SpiDeviceMap spiDeviceMap;
+
+    ReturnValue_t handlePollingSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+            SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen);
+    ReturnValue_t handleInterruptSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+            SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen);
+    ReturnValue_t handleDmaSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+            SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen);
+    ReturnValue_t handleIrqSendOperation(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+            SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen);
+    ReturnValue_t genericIrqSendSetup(uint8_t* recvPtr, SPI_HandleTypeDef& spiHandle,
+            SpiCookie& spiCookie, const uint8_t * sendData, size_t sendLen);
+    ReturnValue_t halErrorHandler(HAL_StatusTypeDef status, spi::TransferModes transferMode);
+
+    static void spiTransferTxCompleteCallback(SPI_HandleTypeDef *hspi, void* args);
+    static void spiTransferRxCompleteCallback(SPI_HandleTypeDef *hspi, void* args);
+    static void spiTransferCompleteCallback(SPI_HandleTypeDef *hspi, void* args);
+    static void spiTransferErrorCallback(SPI_HandleTypeDef *hspi, void* args);
+
+    static void genericIrqHandler(void* irqArgs, spi::TransferStates targetState);
+
+    void printCfgError(const char* const type);
+};
+
+
+
+#endif /* FSFW_HAL_STM32H7_SPI_SPICOMIF_H_ */

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

@@ -0,0 +1,78 @@
+#include "fsfw_hal/stm32h7/spi/SpiCookie.h"
+
+
+SpiCookie::SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferModes transferMode,
+        spi::MspCfgBase* mspCfg, uint32_t spiSpeed, spi::SpiModes spiMode,
+        uint16_t chipSelectGpioPin, GPIO_TypeDef* chipSelectGpioPort, size_t maxRecvSize):
+        deviceAddress(deviceAddress), spiIdx(spiIdx), spiSpeed(spiSpeed), spiMode(spiMode),
+        transferMode(transferMode), chipSelectGpioPin(chipSelectGpioPin),
+        chipSelectGpioPort(chipSelectGpioPort), mspCfg(mspCfg), maxRecvSize(maxRecvSize) {
+    spiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
+    spiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
+    spiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
+    spiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
+    spiHandle.Init.CRCPolynomial     = 7;
+    spiHandle.Init.CRCLength         = SPI_CRC_LENGTH_8BIT;
+    spiHandle.Init.NSS               = SPI_NSS_SOFT;
+    spiHandle.Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;
+    spiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
+    // Recommended setting to avoid glitches
+    spiHandle.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_ENABLE;
+    spiHandle.Init.Mode = SPI_MODE_MASTER;
+    spi::assignSpiMode(spiMode, spiHandle);
+    spiHandle.Init.BaudRatePrescaler = spi::getPrescaler(HAL_RCC_GetHCLKFreq(), spiSpeed);
+}
+
+uint16_t SpiCookie::getChipSelectGpioPin() const {
+    return chipSelectGpioPin;
+}
+
+GPIO_TypeDef* SpiCookie::getChipSelectGpioPort() {
+    return chipSelectGpioPort;
+}
+
+address_t SpiCookie::getDeviceAddress() const {
+    return deviceAddress;
+}
+
+spi::SpiBus SpiCookie::getSpiIdx() const {
+    return spiIdx;
+}
+
+spi::SpiModes SpiCookie::getSpiMode() const {
+    return spiMode;
+}
+
+uint32_t SpiCookie::getSpiSpeed() const {
+    return spiSpeed;
+}
+
+size_t SpiCookie::getMaxRecvSize() const {
+    return maxRecvSize;
+}
+
+SPI_HandleTypeDef& SpiCookie::getSpiHandle() {
+    return spiHandle;
+}
+
+spi::MspCfgBase* SpiCookie::getMspCfg() {
+    return mspCfg;
+}
+
+void SpiCookie::deleteMspCfg() {
+    if(mspCfg != nullptr) {
+        delete mspCfg;
+    }
+}
+
+spi::TransferModes SpiCookie::getTransferMode() const {
+    return transferMode;
+}
+
+void SpiCookie::setTransferState(spi::TransferStates transferState) {
+    this->transferState = transferState;
+}
+
+spi::TransferStates SpiCookie::getTransferState() const {
+    return this->transferState;
+}

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

@@ -0,0 +1,75 @@
+#ifndef FSFW_HAL_STM32H7_SPI_SPICOOKIE_H_
+#define FSFW_HAL_STM32H7_SPI_SPICOOKIE_H_
+
+#include "spiDefinitions.h"
+#include "mspInit.h"
+
+#include "fsfw/devicehandlers/CookieIF.h"
+
+#include "stm32h743xx.h"
+
+/**
+ * @brief   SPI cookie implementation for the STM32H7 device family
+ * @details
+ * This cookie contains and caches device specific information to be used by the
+ * SPI communication interface
+ * @author  R. Mueller
+ */
+class SpiCookie: public CookieIF {
+    friend class SpiComIF;
+public:
+    /**
+     * Allows construction of a SPI cookie for a connected SPI device
+     * @param deviceAddress
+     * @param spiIdx                SPI bus, e.g. SPI1 or SPI2
+     * @param transferMode
+     * @param mspCfg                This is the MSP configuration. The user is expected to supply
+     *                              a valid MSP configuration. See mspInit.h for functions
+     *                              to create one.
+     * @param spiSpeed
+     * @param spiMode
+     * @param chipSelectGpioPin     GPIO port. Don't use a number here, use the 16 bit type
+     *                              definitions supplied in the MCU header file! (e.g. GPIO_PIN_X)
+     * @param chipSelectGpioPort    GPIO port (e.g. GPIOA)
+     * @param maxRecvSize           Maximum expected receive size. Chose as small as possible.
+     */
+    SpiCookie(address_t deviceAddress, spi::SpiBus spiIdx, spi::TransferModes transferMode,
+            spi::MspCfgBase* mspCfg, uint32_t spiSpeed, spi::SpiModes spiMode,
+            uint16_t chipSelectGpioPin, GPIO_TypeDef* chipSelectGpioPort, size_t maxRecvSize);
+
+    uint16_t getChipSelectGpioPin() const;
+    GPIO_TypeDef* getChipSelectGpioPort();
+    address_t getDeviceAddress() const;
+    spi::SpiBus getSpiIdx() const;
+    spi::SpiModes getSpiMode() const;
+    spi::TransferModes getTransferMode() const;
+    uint32_t getSpiSpeed() const;
+    size_t getMaxRecvSize() const;
+    SPI_HandleTypeDef& getSpiHandle();
+
+private:
+    address_t deviceAddress;
+    SPI_HandleTypeDef spiHandle = {};
+    spi::SpiBus spiIdx;
+    uint32_t spiSpeed;
+    spi::SpiModes spiMode;
+    spi::TransferModes transferMode;
+    volatile spi::TransferStates transferState = spi::TransferStates::IDLE;
+    uint16_t chipSelectGpioPin;
+    GPIO_TypeDef* chipSelectGpioPort;
+    // The MSP configuration is cached here. Be careful when using this, it is automatically
+    // deleted by the SPI  communication interface if it is not required anymore!
+    spi::MspCfgBase* mspCfg = nullptr;
+    const size_t maxRecvSize;
+
+    // Only the SpiComIF is allowed to use this to prevent dangling pointers issues
+    spi::MspCfgBase* getMspCfg();
+    void deleteMspCfg();
+
+    void setTransferState(spi::TransferStates transferState);
+    spi::TransferStates getTransferState() const;
+};
+
+
+
+#endif /* FSFW_HAL_STM32H7_SPI_SPICOOKIE_H_ */

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

@@ -0,0 +1,253 @@
+#include "fsfw_hal/stm32h7/dma.h"
+#include "fsfw_hal/stm32h7/spi/mspInit.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+
+#include "stm32h743xx.h"
+#include "stm32h7xx_hal_spi.h"
+#include "stm32h7xx_hal_dma.h"
+#include "stm32h7xx_hal_def.h"
+
+#include <cstdio>
+
+spi::msp_func_t mspInitFunc = nullptr;
+spi::MspCfgBase* mspInitArgs = nullptr;
+
+spi::msp_func_t mspDeinitFunc = nullptr;
+spi::MspCfgBase* mspDeinitArgs = nullptr;
+
+/**
+ * @brief SPI MSP Initialization
+ *        This function configures the hardware resources used in this example:
+ *           - Peripheral's clock enable
+ *           - Peripheral's GPIO Configuration
+ *           - DMA configuration for transmission request by peripheral
+ *           - NVIC configuration for DMA interrupt request enable
+ * @param hspi: SPI handle pointer
+ * @retval None
+ */
+void spi::halMspInitDma(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = dynamic_cast<MspDmaConfigStruct*>(cfgBase);
+    if(hspi == nullptr or cfg == nullptr) {
+        return;
+    }
+    setSpiHandle(hspi);
+
+    DMA_HandleTypeDef* hdma_tx = nullptr;
+    DMA_HandleTypeDef* hdma_rx = nullptr;
+    spi::getDmaHandles(&hdma_tx, &hdma_rx);
+    if(hdma_tx == nullptr or hdma_rx == nullptr) {
+        printf("HAL_SPI_MspInit: Invalid DMA handles. Make sure to call setDmaHandles!\n");
+        return;
+    }
+
+    spi::halMspInitInterrupt(hspi, cfg);
+
+    // DMA setup
+    if(cfg->dmaClkEnableWrapper == nullptr) {
+        mspErrorHandler("spi::halMspInitDma", "DMA Clock init invalid");
+    }
+    cfg->dmaClkEnableWrapper();
+
+    // Configure the DMA
+    /* Configure the DMA handler for Transmission process */
+    if(hdma_tx->Instance == nullptr) {
+        // Assume it was not configured properly
+        mspErrorHandler("spi::halMspInitDma", "DMA TX handle invalid");
+    }
+
+    HAL_DMA_Init(hdma_tx);
+    /* Associate the initialized DMA handle to the the SPI handle */
+    __HAL_LINKDMA(hspi, hdmatx, *hdma_tx);
+
+    HAL_DMA_Init(hdma_rx);
+    /* Associate the initialized DMA handle to the the SPI handle */
+    __HAL_LINKDMA(hspi, hdmarx, *hdma_rx);
+
+    /*##-4- Configure the NVIC for DMA #########################################*/
+    /* NVIC configuration for DMA transfer complete interrupt (SPI1_RX) */
+    // Assign the interrupt handler
+    dma::assignDmaUserHandler(cfg->rxDmaIndex, cfg->rxDmaStream, &spi::dmaRxIrqHandler, hdma_rx);
+    HAL_NVIC_SetPriority(cfg->rxDmaIrqNumber, cfg->rxPreEmptPriority, cfg->rxSubpriority);
+    HAL_NVIC_EnableIRQ(cfg->rxDmaIrqNumber);
+
+    /* NVIC configuration for DMA transfer complete interrupt (SPI1_TX) */
+    // Assign the interrupt handler
+    dma::assignDmaUserHandler(cfg->txDmaIndex, cfg->txDmaStream,
+            &spi::dmaTxIrqHandler, hdma_tx);
+    HAL_NVIC_SetPriority(cfg->txDmaIrqNumber, cfg->txPreEmptPriority, cfg->txSubpriority);
+    HAL_NVIC_EnableIRQ(cfg->txDmaIrqNumber);
+}
+
+/**
+ * @brief SPI MSP De-Initialization
+ *        This function frees the hardware resources used in this example:
+ *          - Disable the Peripheral's clock
+ *          - Revert GPIO, DMA and NVIC configuration to their default state
+ * @param hspi: SPI handle pointer
+ * @retval None
+ */
+void spi::halMspDeinitDma(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = dynamic_cast<MspDmaConfigStruct*>(cfgBase);
+    if(hspi == nullptr or cfg == nullptr) {
+        return;
+    }
+    spi::halMspDeinitInterrupt(hspi, cfgBase);
+    DMA_HandleTypeDef* hdma_tx = NULL;
+    DMA_HandleTypeDef* hdma_rx = NULL;
+    spi::getDmaHandles(&hdma_tx, &hdma_rx);
+    if(hdma_tx == NULL || hdma_rx == NULL) {
+        printf("HAL_SPI_MspInit: Invalid DMA handles. Make sure to call setDmaHandles!\n");
+    }
+    else {
+        // Disable the DMA
+        /* De-Initialize the DMA associated to transmission process */
+        HAL_DMA_DeInit(hdma_tx);
+        /* De-Initialize the DMA associated to reception process */
+        HAL_DMA_DeInit(hdma_rx);
+    }
+
+    // Disable the NVIC for DMA
+    HAL_NVIC_DisableIRQ(cfg->txDmaIrqNumber);
+    HAL_NVIC_DisableIRQ(cfg->rxDmaIrqNumber);
+
+}
+
+void spi::halMspInitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = dynamic_cast<MspPollingConfigStruct*>(cfgBase);
+    GPIO_InitTypeDef GPIO_InitStruct = {};
+    /*##-1- Enable peripherals and GPIO Clocks #################################*/
+    /* Enable GPIO TX/RX clock */
+    cfg->setupMacroWrapper();
+
+    /*##-2- Configure peripheral GPIO ##########################################*/
+    /* SPI SCK GPIO pin configuration  */
+    GPIO_InitStruct.Pin       = cfg->sckPin;
+    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
+    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
+    GPIO_InitStruct.Alternate = cfg->sckAlternateFunction;
+    HAL_GPIO_Init(cfg->sckPort, &GPIO_InitStruct);
+
+    /* SPI MISO GPIO pin configuration  */
+    GPIO_InitStruct.Pin = cfg->misoPin;
+    GPIO_InitStruct.Alternate = cfg->misoAlternateFunction;
+    HAL_GPIO_Init(cfg->misoPort, &GPIO_InitStruct);
+
+    /* SPI MOSI GPIO pin configuration  */
+    GPIO_InitStruct.Pin = cfg->mosiPin;
+    GPIO_InitStruct.Alternate = cfg->mosiAlternateFunction;
+    HAL_GPIO_Init(cfg->mosiPort, &GPIO_InitStruct);
+}
+
+void spi::halMspDeinitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = reinterpret_cast<MspPollingConfigStruct*>(cfgBase);
+    // Reset peripherals
+    cfg->cleanUpMacroWrapper();
+
+    // Disable peripherals and GPIO Clocks
+    /* Configure SPI SCK as alternate function  */
+    HAL_GPIO_DeInit(cfg->sckPort, cfg->sckPin);
+    /* Configure SPI MISO as alternate function  */
+    HAL_GPIO_DeInit(cfg->misoPort, cfg->misoPin);
+    /* Configure SPI MOSI as alternate function  */
+    HAL_GPIO_DeInit(cfg->mosiPort, cfg->mosiPin);
+}
+
+void spi::halMspInitInterrupt(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = dynamic_cast<MspIrqConfigStruct*>(cfgBase);
+    if(cfg == nullptr or hspi == nullptr) {
+        return;
+    }
+
+    spi::halMspInitPolling(hspi, cfg);
+    // Configure the NVIC for SPI
+    spi::assignSpiUserHandler(cfg->spiBus, cfg->spiIrqHandler, cfg->spiUserArgs);
+    HAL_NVIC_SetPriority(cfg->spiIrqNumber, cfg->preEmptPriority, cfg->subpriority);
+    HAL_NVIC_EnableIRQ(cfg->spiIrqNumber);
+}
+
+void spi::halMspDeinitInterrupt(SPI_HandleTypeDef* hspi, MspCfgBase* cfgBase) {
+    auto cfg = dynamic_cast<MspIrqConfigStruct*>(cfgBase);
+    spi::halMspDeinitPolling(hspi, cfg);
+    // Disable the NVIC for SPI
+    HAL_NVIC_DisableIRQ(cfg->spiIrqNumber);
+}
+
+void spi::getMspInitFunction(msp_func_t* init_func, MspCfgBase** args) {
+    if(init_func != NULL && args != NULL) {
+        *init_func = mspInitFunc;
+        *args = mspInitArgs;
+    }
+}
+
+void spi::getMspDeinitFunction(msp_func_t* deinit_func, MspCfgBase** args) {
+    if(deinit_func != NULL && args != NULL) {
+        *deinit_func = mspDeinitFunc;
+        *args = mspDeinitArgs;
+    }
+}
+
+void spi::setSpiDmaMspFunctions(MspDmaConfigStruct* cfg,
+        msp_func_t initFunc, msp_func_t deinitFunc) {
+    mspInitFunc = initFunc;
+    mspDeinitFunc = deinitFunc;
+    mspInitArgs = cfg;
+    mspDeinitArgs = cfg;
+}
+
+void spi::setSpiIrqMspFunctions(MspIrqConfigStruct *cfg, msp_func_t initFunc,
+        msp_func_t deinitFunc) {
+    mspInitFunc = initFunc;
+    mspDeinitFunc = deinitFunc;
+    mspInitArgs = cfg;
+    mspDeinitArgs = cfg;
+}
+
+void spi::setSpiPollingMspFunctions(MspPollingConfigStruct *cfg, msp_func_t initFunc,
+        msp_func_t deinitFunc) {
+    mspInitFunc = initFunc;
+    mspDeinitFunc = deinitFunc;
+    mspInitArgs = cfg;
+    mspDeinitArgs = cfg;
+}
+
+/**
+ * @brief SPI MSP Initialization
+ *        This function configures the hardware resources used in this example:
+ *           - Peripheral's clock enable
+ *           - Peripheral's GPIO Configuration
+ *           - DMA configuration for transmission request by peripheral
+ *           - NVIC configuration for DMA interrupt request enable
+ * @param hspi: SPI handle pointer
+ * @retval None
+ */
+extern "C" void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) {
+    if(mspInitFunc != NULL) {
+        mspInitFunc(hspi, mspInitArgs);
+    }
+    else {
+        printf("HAL_SPI_MspInit: Please call set_msp_functions to assign SPI MSP functions\n");
+    }
+}
+
+/**
+ * @brief SPI MSP De-Initialization
+ *        This function frees the hardware resources used in this example:
+ *          - Disable the Peripheral's clock
+ *          - Revert GPIO, DMA and NVIC configuration to their default state
+ * @param hspi: SPI handle pointer
+ * @retval None
+ */
+extern "C" void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi) {
+    if(mspDeinitFunc != NULL) {
+        mspDeinitFunc(hspi, mspDeinitArgs);
+    }
+    else {
+        printf("HAL_SPI_MspDeInit: Please call set_msp_functions to assign SPI MSP functions\n");
+    }
+}
+
+void spi::mspErrorHandler(const char* const function, const char *const message) {
+    printf("%s failure: %s\n", function, message);
+}

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

@@ -0,0 +1,114 @@
+#ifndef FSFW_HAL_STM32H7_SPI_MSPINIT_H_
+#define FSFW_HAL_STM32H7_SPI_MSPINIT_H_
+
+#include "spiDefinitions.h"
+#include "../dma.h"
+
+#include "stm32h7xx_hal_spi.h"
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   This file provides MSP implementation for DMA, IRQ and Polling mode for the
+ *          SPI peripheral. This configuration is required for the SPI communication to work.
+ */
+namespace spi {
+
+struct MspCfgBase {
+    virtual ~MspCfgBase() = default;
+
+    void (* cleanUpMacroWrapper) (void) = nullptr;
+    void (* setupMacroWrapper) (void) = nullptr;
+
+   GPIO_TypeDef* sckPort = nullptr;
+   uint32_t sckPin = 0;
+   uint8_t sckAlternateFunction = 0;
+   GPIO_TypeDef* mosiPort = nullptr;
+   uint32_t mosiPin = 0;
+   uint8_t mosiAlternateFunction = 0;
+   GPIO_TypeDef* misoPort = nullptr;
+   uint32_t misoPin = 0;
+   uint8_t misoAlternateFunction = 0;
+};
+
+struct MspPollingConfigStruct: public MspCfgBase {};
+
+/* A valid instance of this struct must be passed to the MSP initialization function as a void*
+argument */
+struct MspIrqConfigStruct: public MspPollingConfigStruct {
+    SpiBus spiBus = SpiBus::SPI_1;
+    user_handler_t spiIrqHandler = nullptr;
+    user_args_t spiUserArgs = nullptr;
+    IRQn_Type spiIrqNumber = SPI1_IRQn;
+    // Priorities for NVIC
+    // Pre-Empt priority ranging from 0 to 15. If FreeRTOS calls are used, only 5-15 are allowed
+    IrqPriorities preEmptPriority = IrqPriorities::LOWEST;
+    IrqPriorities subpriority = IrqPriorities::LOWEST;
+};
+
+/* A valid instance of this struct must be passed to the MSP initialization function as a void*
+argument */
+struct MspDmaConfigStruct: public MspIrqConfigStruct {
+    void (* dmaClkEnableWrapper) (void) = nullptr;
+    dma::DMAIndexes txDmaIndex;
+    dma::DMAIndexes rxDmaIndex;
+    dma::DMAStreams txDmaStream;
+    dma::DMAStreams rxDmaStream;
+    IRQn_Type txDmaIrqNumber = DMA1_Stream0_IRQn;
+    IRQn_Type rxDmaIrqNumber = DMA1_Stream1_IRQn;
+    // Priorities for NVIC
+    IrqPriorities txPreEmptPriority = IrqPriorities::LOWEST;
+    IrqPriorities rxPreEmptPriority = IrqPriorities::LOWEST;
+    IrqPriorities txSubpriority = IrqPriorities::LOWEST;
+    IrqPriorities rxSubpriority = IrqPriorities::LOWEST;
+};
+
+using msp_func_t = void (*) (SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+
+
+void getMspInitFunction(msp_func_t* init_func, MspCfgBase **args);
+void getMspDeinitFunction(msp_func_t* deinit_func, MspCfgBase **args);
+
+void halMspInitDma(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+void halMspDeinitDma(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+
+void halMspInitInterrupt(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+void halMspDeinitInterrupt(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+
+void halMspInitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+void halMspDeinitPolling(SPI_HandleTypeDef* hspi, MspCfgBase* cfg);
+
+/**
+ * Assign MSP init functions. Important for SPI configuration
+ * @param init_func
+ * @param init_args
+ * @param deinit_func
+ * @param deinit_args
+ */
+void setSpiDmaMspFunctions(MspDmaConfigStruct* cfg,
+        msp_func_t initFunc = &spi::halMspInitDma,
+        msp_func_t deinitFunc= &spi::halMspDeinitDma
+);
+void setSpiIrqMspFunctions(MspIrqConfigStruct* cfg,
+        msp_func_t initFunc = &spi::halMspInitInterrupt,
+        msp_func_t deinitFunc= &spi::halMspDeinitInterrupt
+);
+void setSpiPollingMspFunctions(MspPollingConfigStruct* cfg,
+        msp_func_t initFunc = &spi::halMspInitPolling,
+        msp_func_t deinitFunc= &spi::halMspDeinitPolling
+);
+
+void mspErrorHandler(const char* const function, const char *const message);
+
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_HAL_STM32H7_SPI_MSPINIT_H_ */

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

@@ -0,0 +1,341 @@
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+
+#include <cstdio>
+
+SPI_HandleTypeDef* spiHandle = nullptr;
+DMA_HandleTypeDef* hdmaTx = nullptr;
+DMA_HandleTypeDef* hdmaRx = nullptr;
+
+spi_transfer_cb_t rxTxCb = nullptr;
+void* rxTxArgs = nullptr;
+spi_transfer_cb_t txCb = nullptr;
+void* txArgs = nullptr;
+spi_transfer_cb_t rxCb = nullptr;
+void* rxArgs = nullptr;
+spi_transfer_cb_t errorCb = nullptr;
+void* errorArgs = nullptr;
+
+void mapIndexAndStream(DMA_HandleTypeDef* handle, dma::DMAType dmaType, dma::DMAIndexes dmaIdx,
+        dma::DMAStreams dmaStream, IRQn_Type* dmaIrqNumber);
+void mapSpiBus(DMA_HandleTypeDef *handle, dma::DMAType dmaType, spi::SpiBus spiBus);
+
+void spi::configureDmaHandle(DMA_HandleTypeDef *handle, spi::SpiBus spiBus, dma::DMAType dmaType,
+        dma::DMAIndexes dmaIdx, dma::DMAStreams dmaStream, IRQn_Type* dmaIrqNumber,
+        uint32_t dmaMode, uint32_t dmaPriority) {
+    using namespace dma;
+    mapIndexAndStream(handle, dmaType, dmaIdx, dmaStream, dmaIrqNumber);
+    mapSpiBus(handle, dmaType, spiBus);
+
+    if(dmaType == DMAType::TX) {
+        handle->Init.Direction = DMA_MEMORY_TO_PERIPH;
+    }
+    else {
+        handle->Init.Direction = DMA_PERIPH_TO_MEMORY;
+    }
+
+    handle->Init.Priority = dmaPriority;
+    handle->Init.Mode = dmaMode;
+
+    // Standard settings for the rest for now
+    handle->Init.FIFOMode            = DMA_FIFOMODE_DISABLE;
+    handle->Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;
+    handle->Init.MemBurst            = DMA_MBURST_INC4;
+    handle->Init.PeriphBurst         = DMA_PBURST_INC4;
+    handle->Init.PeriphInc           = DMA_PINC_DISABLE;
+    handle->Init.MemInc              = DMA_MINC_ENABLE;
+    handle->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
+    handle->Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;
+}
+
+void spi::setDmaHandles(DMA_HandleTypeDef* txHandle, DMA_HandleTypeDef* rxHandle) {
+    hdmaTx = txHandle;
+    hdmaRx = rxHandle;
+}
+
+void spi::getDmaHandles(DMA_HandleTypeDef** txHandle, DMA_HandleTypeDef** rxHandle) {
+    *txHandle = hdmaTx;
+    *rxHandle = hdmaRx;
+}
+
+void spi::setSpiHandle(SPI_HandleTypeDef *spiHandle_) {
+    if(spiHandle_ == NULL) {
+        return;
+    }
+    spiHandle = spiHandle_;
+}
+
+void spi::assignTransferRxTxCompleteCallback(spi_transfer_cb_t callback, void *userArgs) {
+    rxTxCb = callback;
+    rxTxArgs = userArgs;
+}
+
+void spi::assignTransferRxCompleteCallback(spi_transfer_cb_t callback, void *userArgs) {
+    rxCb = callback;
+    rxArgs = userArgs;
+}
+
+void spi::assignTransferTxCompleteCallback(spi_transfer_cb_t callback, void *userArgs) {
+    txCb = callback;
+    txArgs = userArgs;
+}
+
+void spi::assignTransferErrorCallback(spi_transfer_cb_t callback, void *userArgs) {
+    errorCb = callback;
+    errorArgs = userArgs;
+}
+
+SPI_HandleTypeDef* spi::getSpiHandle() {
+    return spiHandle;
+}
+
+
+
+/**
+ * @brief  TxRx Transfer completed callback.
+ * @param  hspi: SPI handle
+ */
+extern "C" void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) {
+    if(rxTxCb != NULL) {
+        rxTxCb(hspi, rxTxArgs);
+    }
+    else {
+        printf("HAL_SPI_TxRxCpltCallback: No user callback specified\n");
+    }
+}
+
+/**
+ * @brief  TxRx Transfer completed callback.
+ * @param  hspi: SPI handle
+ */
+extern "C" void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) {
+    if(txCb != NULL) {
+        txCb(hspi, txArgs);
+    }
+    else {
+        printf("HAL_SPI_TxCpltCallback: No user callback specified\n");
+    }
+}
+
+/**
+ * @brief  TxRx Transfer completed callback.
+ * @param  hspi: SPI handle
+ */
+extern "C" void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) {
+    if(rxCb != nullptr) {
+        rxCb(hspi, rxArgs);
+    }
+    else {
+        printf("HAL_SPI_RxCpltCallback: No user callback specified\n");
+    }
+}
+
+/**
+ * @brief  SPI error callbacks.
+ * @param  hspi: SPI handle
+ * @note   This example shows a simple way to report transfer error, and you can
+ *         add your own implementation.
+ * @retval None
+ */
+extern "C" void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) {
+    if(errorCb != nullptr) {
+        errorCb(hspi, rxArgs);
+    }
+    else {
+        printf("HAL_SPI_ErrorCallback: No user callback specified\n");
+    }
+}
+
+void mapIndexAndStream(DMA_HandleTypeDef* handle, dma::DMAType dmaType, dma::DMAIndexes dmaIdx,
+        dma::DMAStreams dmaStream, IRQn_Type* dmaIrqNumber) {
+    using namespace dma;
+    if(dmaIdx == DMAIndexes::DMA_1) {
+#ifdef DMA1
+        switch(dmaStream) {
+        case(DMAStreams::STREAM_0): {
+#ifdef DMA1_Stream0
+            handle->Instance = DMA1_Stream0;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream0_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_1): {
+#ifdef DMA1_Stream1
+            handle->Instance = DMA1_Stream1;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream1_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_2): {
+#ifdef DMA1_Stream2
+            handle->Instance = DMA1_Stream2;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream2_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_3): {
+#ifdef DMA1_Stream3
+            handle->Instance = DMA1_Stream3;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream3_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_4): {
+#ifdef DMA1_Stream4
+            handle->Instance = DMA1_Stream4;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream4_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_5): {
+#ifdef DMA1_Stream5
+            handle->Instance = DMA1_Stream5;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream5_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_6): {
+#ifdef DMA1_Stream6
+            handle->Instance = DMA1_Stream6;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream6_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_7): {
+#ifdef DMA1_Stream7
+            handle->Instance = DMA1_Stream7;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA1_Stream7_IRQn;
+            }
+#endif
+            break;
+        }
+        }
+        if(dmaType == DMAType::TX) {
+            handle->Init.Request = DMA_REQUEST_SPI1_TX;
+        }
+        else {
+            handle->Init.Request = DMA_REQUEST_SPI1_RX;
+        }
+#endif /* DMA1 */
+    }
+    if(dmaIdx == DMAIndexes::DMA_2) {
+#ifdef DMA2
+        switch(dmaStream) {
+        case(DMAStreams::STREAM_0): {
+#ifdef DMA2_Stream0
+            handle->Instance = DMA2_Stream0;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream0_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_1): {
+#ifdef DMA2_Stream1
+            handle->Instance = DMA2_Stream1;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream1_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_2): {
+#ifdef DMA2_Stream2
+            handle->Instance = DMA2_Stream2;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream2_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_3): {
+#ifdef DMA2_Stream3
+            handle->Instance = DMA2_Stream3;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream3_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_4): {
+#ifdef DMA2_Stream4
+            handle->Instance = DMA2_Stream4;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream4_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_5): {
+#ifdef DMA2_Stream5
+            handle->Instance = DMA2_Stream5;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream5_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_6): {
+#ifdef DMA2_Stream6
+            handle->Instance = DMA2_Stream6;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream6_IRQn;
+            }
+#endif
+            break;
+        }
+        case(DMAStreams::STREAM_7): {
+#ifdef DMA2_Stream7
+            handle->Instance = DMA2_Stream7;
+            if(dmaIrqNumber != nullptr) {
+                *dmaIrqNumber = DMA2_Stream7_IRQn;
+            }
+#endif
+            break;
+        }
+        }
+#endif /* DMA2 */
+    }
+}
+
+void mapSpiBus(DMA_HandleTypeDef *handle, dma::DMAType dmaType, spi::SpiBus spiBus) {
+    if(dmaType == dma::DMAType::TX) {
+        if(spiBus == spi::SpiBus::SPI_1) {
+#ifdef DMA_REQUEST_SPI1_TX
+            handle->Init.Request = DMA_REQUEST_SPI1_TX;
+#endif
+        }
+        else if(spiBus == spi::SpiBus::SPI_2) {
+#ifdef DMA_REQUEST_SPI2_TX
+            handle->Init.Request = DMA_REQUEST_SPI2_TX;
+#endif
+        }
+    }
+    else {
+        if(spiBus == spi::SpiBus::SPI_1) {
+#ifdef DMA_REQUEST_SPI1_RX
+            handle->Init.Request = DMA_REQUEST_SPI1_RX;
+#endif
+        }
+        else if(spiBus == spi::SpiBus::SPI_2) {
+#ifdef DMA_REQUEST_SPI2_RX
+            handle->Init.Request = DMA_REQUEST_SPI2_RX;
+#endif
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+#ifndef FSFW_HAL_STM32H7_SPI_SPICORE_H_
+#define FSFW_HAL_STM32H7_SPI_SPICORE_H_
+
+#include "fsfw_hal/stm32h7/dma.h"
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+
+#include "stm32h7xx_hal.h"
+#include "stm32h7xx_hal_dma.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+using spi_transfer_cb_t = void (*) (SPI_HandleTypeDef *hspi, void* userArgs);
+
+namespace spi {
+
+void configureDmaHandle(DMA_HandleTypeDef* handle, spi::SpiBus spiBus,
+        dma::DMAType dmaType, dma::DMAIndexes dmaIdx,
+        dma::DMAStreams dmaStream, IRQn_Type* dmaIrqNumber, uint32_t dmaMode = DMA_NORMAL,
+        uint32_t dmaPriority = DMA_PRIORITY_LOW);
+
+/**
+ * Assign DMA handles. Required to use DMA for SPI transfers.
+ * @param txHandle
+ * @param rxHandle
+ */
+void setDmaHandles(DMA_HandleTypeDef* txHandle, DMA_HandleTypeDef* rxHandle);
+void getDmaHandles(DMA_HandleTypeDef** txHandle, DMA_HandleTypeDef** rxHandle);
+
+/**
+ * Assign SPI handle. Needs to be done before using the SPI
+ * @param spiHandle
+ */
+void setSpiHandle(SPI_HandleTypeDef *spiHandle);
+
+void assignTransferRxTxCompleteCallback(spi_transfer_cb_t callback, void* userArgs);
+void assignTransferRxCompleteCallback(spi_transfer_cb_t callback, void* userArgs);
+void assignTransferTxCompleteCallback(spi_transfer_cb_t callback, void* userArgs);
+void assignTransferErrorCallback(spi_transfer_cb_t callback, void* userArgs);
+
+/**
+ * Get the assigned SPI handle.
+ * @return
+ */
+SPI_HandleTypeDef* getSpiHandle();
+
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_HAL_STM32H7_SPI_SPICORE_H_ */

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

@@ -0,0 +1,52 @@
+#include "fsfw_hal/stm32h7/spi/spiDefinitions.h"
+
+void spi::assignSpiMode(SpiModes spiMode, SPI_HandleTypeDef& spiHandle) {
+    switch(spiMode) {
+    case(SpiModes::MODE_0): {
+        spiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
+        spiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
+        break;
+    }
+    case(SpiModes::MODE_1): {
+        spiHandle.Init.CLKPolarity = SPI_POLARITY_LOW;
+        spiHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
+        break;
+    }
+    case(SpiModes::MODE_2): {
+        spiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
+        spiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
+        break;
+    }
+    case(SpiModes::MODE_3): {
+        spiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
+        spiHandle.Init.CLKPhase = SPI_PHASE_2EDGE;
+        break;
+    }
+    }
+}
+
+uint32_t spi::getPrescaler(uint32_t clock_src_freq, uint32_t baudrate_mbps) {
+    uint32_t divisor = 0;
+    uint32_t spi_clk = clock_src_freq;
+    uint32_t presc = 0;
+    static const uint32_t baudrate[] = {
+            SPI_BAUDRATEPRESCALER_2,
+            SPI_BAUDRATEPRESCALER_4,
+            SPI_BAUDRATEPRESCALER_8,
+            SPI_BAUDRATEPRESCALER_16,
+            SPI_BAUDRATEPRESCALER_32,
+            SPI_BAUDRATEPRESCALER_64,
+            SPI_BAUDRATEPRESCALER_128,
+            SPI_BAUDRATEPRESCALER_256,
+    };
+
+    while( spi_clk > baudrate_mbps) {
+        presc = baudrate[divisor];
+        if (++divisor > 7)
+            break;
+
+        spi_clk = ( spi_clk >> 1);
+    }
+
+    return presc;
+}

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

@@ -0,0 +1,50 @@
+#ifndef FSFW_HAL_STM32H7_SPI_SPIDEFINITIONS_H_
+#define FSFW_HAL_STM32H7_SPI_SPIDEFINITIONS_H_
+
+#include "../../common/spi/spiCommon.h"
+
+#include "fsfw/returnvalues/FwClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+#include "stm32h7xx_hal.h"
+#include "stm32h7xx_hal_spi.h"
+
+namespace spi {
+
+static constexpr uint8_t HAL_SPI_ID = CLASS_ID::HAL_SPI;
+static constexpr ReturnValue_t HAL_TIMEOUT_RETVAL = HasReturnvaluesIF::makeReturnCode(HAL_SPI_ID, 0);
+static constexpr ReturnValue_t HAL_BUSY_RETVAL = HasReturnvaluesIF::makeReturnCode(HAL_SPI_ID, 1);
+static constexpr ReturnValue_t HAL_ERROR_RETVAL = HasReturnvaluesIF::makeReturnCode(HAL_SPI_ID, 2);
+
+enum class TransferStates {
+    IDLE,
+    WAIT,
+    SUCCESS,
+    FAILURE
+};
+
+enum SpiBus {
+    SPI_1,
+    SPI_2
+};
+
+enum TransferModes {
+    POLLING,
+    INTERRUPT,
+    DMA
+};
+
+void assignSpiMode(SpiModes spiMode, SPI_HandleTypeDef& spiHandle);
+
+/**
+ * @brief  Set SPI frequency to calculate correspondent baud-rate prescaler.
+ * @param  clock_src_freq  Frequency of clock source
+ * @param  baudrate_mbps Baudrate to set to set
+ * @retval Baudrate prescaler
+ */
+uint32_t getPrescaler(uint32_t clock_src_freq, uint32_t baudrate_mbps);
+
+}
+
+
+#endif /* FSFW_HAL_STM32H7_SPI_SPIDEFINITIONS_H_ */

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

@@ -0,0 +1,106 @@
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+
+#include "stm32h7xx_hal.h"
+#include "stm32h7xx_hal_dma.h"
+#include "stm32h7xx_hal_spi.h"
+
+#include <stddef.h>
+
+user_handler_t spi1UserHandler = &spi::spiIrqHandler;
+user_args_t spi1UserArgs = nullptr;
+
+user_handler_t spi2UserHandler = &spi::spiIrqHandler;
+user_args_t spi2UserArgs = nullptr;
+
+/**
+ * @brief  This function handles DMA Rx interrupt request.
+ * @param  None
+ * @retval None
+ */
+void spi::dmaRxIrqHandler(void* dmaHandle) {
+    if(dmaHandle == nullptr) {
+        return;
+    }
+    HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dmaHandle);
+}
+
+/**
+ * @brief  This function handles DMA Rx interrupt request.
+ * @param  None
+ * @retval None
+ */
+void spi::dmaTxIrqHandler(void* dmaHandle) {
+    if(dmaHandle == nullptr) {
+        return;
+    }
+    HAL_DMA_IRQHandler((DMA_HandleTypeDef *) dmaHandle);
+}
+
+/**
+ * @brief  This function handles SPIx interrupt request.
+ * @param  None
+ * @retval None
+ */
+void spi::spiIrqHandler(void* spiHandle) {
+    if(spiHandle == nullptr) {
+        return;
+    }
+    //auto currentSpiHandle = spi::getSpiHandle();
+    HAL_SPI_IRQHandler((SPI_HandleTypeDef *) spiHandle);
+}
+
+void spi::assignSpiUserHandler(spi::SpiBus spiIdx, user_handler_t userHandler,
+        user_args_t userArgs) {
+    if(spiIdx == spi::SpiBus::SPI_1) {
+        spi1UserHandler = userHandler;
+        spi1UserArgs = userArgs;
+    }
+    else {
+        spi2UserHandler = userHandler;
+        spi2UserArgs = userArgs;
+    }
+}
+
+void spi::getSpiUserHandler(spi::SpiBus spiBus, user_handler_t *userHandler,
+        user_args_t *userArgs) {
+    if(userHandler == nullptr or userArgs == nullptr) {
+        return;
+    }
+    if(spiBus == spi::SpiBus::SPI_1) {
+        *userArgs = spi1UserArgs;
+        *userHandler = spi1UserHandler;
+    }
+    else {
+        *userArgs = spi2UserArgs;
+        *userHandler = spi2UserHandler;
+    }
+}
+
+void spi::assignSpiUserArgs(spi::SpiBus spiBus, user_args_t userArgs) {
+    if(spiBus == spi::SpiBus::SPI_1) {
+        spi1UserArgs = userArgs;
+    }
+    else {
+        spi2UserArgs = userArgs;
+    }
+}
+
+/* Do not change these function names! They need to be exactly equal to the name of the functions
+defined in the startup_stm32h743xx.s files! */
+
+extern "C" void SPI1_IRQHandler() {
+    if(spi1UserHandler != NULL) {
+        spi1UserHandler(spi1UserArgs);
+        return;
+    }
+    Default_Handler();
+}
+
+extern "C"  void SPI2_IRQHandler() {
+    if(spi2UserHandler != nullptr) {
+        spi2UserHandler(spi2UserArgs);
+        return;
+    }
+    Default_Handler();
+}

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

@@ -0,0 +1,41 @@
+#ifndef FSFW_HAL_STM32H7_SPI_INTERRUPTS_H_
+#define FSFW_HAL_STM32H7_SPI_INTERRUPTS_H_
+
+#include "../interrupts.h"
+#include "spiDefinitions.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace spi {
+
+void assignSpiUserArgs(spi::SpiBus spiBus, user_args_t userArgs);
+
+/**
+ * Assign a user interrupt handler for SPI bus 1, allowing to pass an arbitrary argument as well.
+ * Generally, this argument will be the related SPI handle.
+ * @param user_handler
+ * @param user_args
+ */
+void assignSpiUserHandler(spi::SpiBus spiBus, user_handler_t user_handler,
+        user_args_t user_args);
+void getSpiUserHandler(spi::SpiBus spiBus, user_handler_t* user_handler,
+        user_args_t* user_args);
+
+/**
+ * Generic interrupt handlers supplied for convenience. Do not call these directly! Set them
+ * instead with assign_dma_user_handler and assign_spi_user_handler functions.
+ * @param dma_handle
+ */
+void dmaRxIrqHandler(void* dma_handle);
+void dmaTxIrqHandler(void* dma_handle);
+void spiIrqHandler(void* spi_handle);
+
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_HAL_STM32H7_SPI_INTERRUPTS_H_ */

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

@@ -0,0 +1,82 @@
+#include "fsfw_hal/stm32h7/spi/stm32h743ziSpi.h"
+#include "fsfw_hal/stm32h7/spi/spiCore.h"
+#include "fsfw_hal/stm32h7/spi/spiInterrupts.h"
+
+#include "stm32h7xx_hal.h"
+#include "stm32h7xx_hal_rcc.h"
+
+#include <cstdio>
+
+void spiSetupWrapper() {
+    __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_GPIOB_CLK_ENABLE();
+    __HAL_RCC_SPI1_CLK_ENABLE();
+}
+
+void spiCleanUpWrapper() {
+    __HAL_RCC_SPI1_FORCE_RESET();
+    __HAL_RCC_SPI1_RELEASE_RESET();
+}
+
+void spiDmaClockEnableWrapper() {
+    __HAL_RCC_DMA2_CLK_ENABLE();
+}
+
+void spi::h743zi::standardPollingCfg(MspPollingConfigStruct& cfg) {
+    cfg.setupMacroWrapper =  &spiSetupWrapper;
+    cfg.cleanUpMacroWrapper = &spiCleanUpWrapper;
+    cfg.sckPort = GPIOA;
+    cfg.sckPin = GPIO_PIN_5;
+    cfg.misoPort = GPIOA;
+    cfg.misoPin = GPIO_PIN_6;
+    cfg.mosiPort = GPIOA;
+    cfg.mosiPin = GPIO_PIN_7;
+    cfg.sckAlternateFunction = GPIO_AF5_SPI1;
+    cfg.mosiAlternateFunction = GPIO_AF5_SPI1;
+    cfg.misoAlternateFunction = GPIO_AF5_SPI1;
+}
+
+void spi::h743zi::standardInterruptCfg(MspIrqConfigStruct& cfg, IrqPriorities spiIrqPrio,
+        IrqPriorities spiSubprio) {
+    // High, but works on FreeRTOS as well (priorities range from 0 to 15)
+    cfg.preEmptPriority = spiIrqPrio;
+    cfg.subpriority = spiSubprio;
+    cfg.spiIrqNumber = SPI1_IRQn;
+    cfg.spiBus = SpiBus::SPI_1;
+    user_handler_t spiUserHandler = nullptr;
+    user_args_t spiUserArgs = nullptr;
+    getSpiUserHandler(spi::SpiBus::SPI_1, &spiUserHandler, &spiUserArgs);
+    if(spiUserHandler == nullptr) {
+        printf("spi::h743zi::standardInterruptCfg: Invalid SPI user handlers\n");
+        return;
+    }
+    cfg.spiUserArgs = spiUserArgs;
+    cfg.spiIrqHandler = spiUserHandler;
+    standardPollingCfg(cfg);
+}
+
+void spi::h743zi::standardDmaCfg(MspDmaConfigStruct& cfg, IrqPriorities spiIrqPrio,
+        IrqPriorities txIrqPrio, IrqPriorities rxIrqPrio, IrqPriorities spiSubprio,
+        IrqPriorities txSubprio, IrqPriorities rxSubprio) {
+    cfg.dmaClkEnableWrapper = &spiDmaClockEnableWrapper;
+    cfg.rxDmaIndex = dma::DMAIndexes::DMA_2;
+    cfg.txDmaIndex = dma::DMAIndexes::DMA_2;
+    cfg.txDmaStream = dma::DMAStreams::STREAM_3;
+    cfg.rxDmaStream = dma::DMAStreams::STREAM_2;
+    DMA_HandleTypeDef* txHandle;
+    DMA_HandleTypeDef* rxHandle;
+    spi::getDmaHandles(&txHandle, &rxHandle);
+    if(txHandle == nullptr or rxHandle == nullptr) {
+        printf("spi::h743zi::standardDmaCfg: Invalid DMA handles\n");
+        return;
+    }
+    spi::configureDmaHandle(txHandle, spi::SpiBus::SPI_1, dma::DMAType::TX, cfg.txDmaIndex,
+            cfg.txDmaStream, &cfg.txDmaIrqNumber);
+    spi::configureDmaHandle(rxHandle, spi::SpiBus::SPI_1, dma::DMAType::RX, cfg.rxDmaIndex,
+            cfg.rxDmaStream, &cfg.rxDmaIrqNumber, DMA_NORMAL, DMA_PRIORITY_HIGH);
+    cfg.txPreEmptPriority = txIrqPrio;
+    cfg.rxPreEmptPriority = txSubprio;
+    cfg.txSubpriority = rxIrqPrio;
+    cfg.rxSubpriority = rxSubprio;
+    standardInterruptCfg(cfg, spiIrqPrio, spiSubprio);
+}

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

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

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

@@ -0,0 +1,2 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+)