Merge pull request 'Increased TM stack robustness' (#501) from eive/fsfw:mueller/tm-stack-robustness-cherry-picked into master

Reviewed-on: fsfw/fsfw#501
Reviewed-by: Ulrich Mohr <mohr@irs.uni-stuttgart.de>

CHANGELOG

@@ -1,4 +1,81 @@
-## Changes from ASTP 0.0.1 to 1.0.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
 
 ### Host OSAL
 
@@ -22,7 +99,9 @@ a C file without issues
 
 ### Local Pool
 
-- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and bucket number of the pools per page and the number of pages are passed to the ctor instead of two ctor arguments and a template parameter
+- Interface of LocalPools has changed. LocalPool is not a template anymore. Instead the size and
+bucket number of the pools per page and the number of pages are passed to the ctor instead of
+two ctor arguments and a template parameter
 
 ### Parameter Service
 
@@ -40,7 +119,8 @@ important use-case)
    
 ### File System Interface
 
-- A new interfaces specifies the functions for a software object which exposes the file system of a given hardware to use message based file handling (e.g. PUS commanding)
+- A new interfaces specifies the functions for a software object which exposes the file system of
+a given hardware to use message based file handling (e.g. PUS commanding)
 
 ### Internal Error Reporter
 
@@ -52,7 +132,8 @@ ID for now.
 ### Device Handler Base
 
 - There is an additional `PERFORM_OPERATION` step for the device handler base. It is important
-that DHB users adapt their polling sequence tables to perform this step. This steps allows for aclear distinction between operation and communication steps
+that DHB users adapt their polling sequence tables to perform this step. This steps allows for 
+a clear distinction between operation and communication steps
 - setNormalDatapoolEntriesInvalid is not an abstract method and a default implementation was provided
 - getTransitionDelayMs is now an abstract method
 
@@ -69,7 +150,8 @@ now
 
 ### Commanding Service Base
 
-- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each CSB instance. This variable has to be set in the FSFWConfig.h file
+- CSB uses the new fsfwconfig::FSFW_CSB_FIFO_DEPTH variable to determine  the FIFO depth for each 
+CSB instance. This variable has to be set in the FSFWConfig.h file
 
 ### Service Interface
 
@@ -81,4 +163,13 @@ now
   For the fsfw, this can be done by checking the processor define FSFW_CPP_OSTREAM_ENABLED from FSFWConfig.h. 
   For mission code, developers need to replace sif:: calls by the printf counterparts, but only if the CPP stream are excluded. 
   If this is not the case, everything should work as usual.
-- 
+
+### ActionHelper and ActionMessage
+
+- ActionHelper finish function and ActionMessage::setCompletionReply now expects explicit 
+information whether to report a success or failure message instead of deriving it implicitely 
+from returnvalue
+
+### PUS Parameter Service 20
+
+Added PUS parameter service 20 (only custom subservices available).

CMakeLists.txt

@@ -1,40 +1,82 @@
 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_USE_DATALINKLAYER "Compile with Data Link Layer" ON)
+option(FSFW_ADD_INTERNAL_TESTS "Add internal unit tests" 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 OS_FSFW)
-	message(STATUS "No OS for FSFW via OS_FSFW set. Assuming host OS")
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD_REQUIRED True)
+elseif(${CMAKE_CXX_STANDARD} LESS 11)
+    message(FATAL_ERROR "Compiling the FSFW requires a minimum of C++11 support")
+endif()
+
+# Backwards comptability
+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()
 
-if(${OS_FSFW} STREQUAL host)
+set(FSFW_OSAL_DEFINITION FSFW_OSAL_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")
-elseif(${OS_FSFW} STREQUAL  freertos)
+    set(FSFW_OSAL_LINUX ON)
+elseif(FSFW_OSAL MATCHES freertos)
     set(OS_FSFW_NAME "FreeRTOS")
-	target_link_libraries(${LIB_FSFW_NAME} ${LIB_OS_NAME})
-elseif(${OS_FSFW} STREQUAL rtems)
+    set(FSFW_OSAL_FREERTOS ON)
+    target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+        ${LIB_OS_NAME}
+    )
+elseif(FSFW_OSAL STREQUAL rtems)
     set(OS_FSFW_NAME "RTEMS")
+    set(FSFW_OSAL_RTEMS ON)
 else()
     message(WARNING
         "Invalid operating system for FSFW specified! Setting to host.."
@@ -45,51 +87,12 @@ endif()
 
 message(STATUS "Compiling FSFW for the ${OS_FSFW_NAME} operating system.")
 
-
-
-add_subdirectory(action)
-add_subdirectory(container)
-add_subdirectory(controller)
-add_subdirectory(coordinates)
-
-if(FSFW_USE_DATALINKLAYER)
-	add_subdirectory(datalinklayer)
+add_subdirectory(src)
+add_subdirectory(tests)
+if(FSFW_ADD_HAL)
+    add_subdirectory(hal)
 endif()
-
-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(contrib)
 
 # 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.
@@ -109,16 +112,44 @@ else()
 	)
 endif()
 
+foreach(INCLUDE_PATH ${FSFW_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_ADD_INC_PATHS_ABS ${CURR_ABS_INC_PATH})
+endforeach()
+
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if(NOT DEFINED FSFW_WARNING_FLAGS)
 	   set(FSFW_WARNING_FLAGS
 		  -Wall
 		  -Wextra
-		  -Wshadow=local
 		  -Wimplicit-fallthrough=1
 		  -Wno-unused-parameter
 		  -Wno-psabi
         )
+    endif()
+
+    if(FSFW_GENERATE_SECTIONS)
+        target_compile_options(${LIB_FSFW_NAME} PRIVATE
+            "-ffunction-sections"
+            "-fdata-sections"
+        )
+    endif()
+
+    if(FSFW_REMOVE_UNUSED_CODE)
+        target_link_options(${LIB_FSFW_NAME} PRIVATE
+            "Wl,--gc-sections"
+        )
+    endif()
   
     if(FSFW_WARNING_SHADOW_LOCAL_GCC)
         list(APPEND WARNING_FLAGS "-Wshadow=local")
@@ -134,6 +165,8 @@ endif()
 target_include_directories(${LIB_FSFW_NAME} INTERFACE 
 	${CMAKE_SOURCE_DIR}
 	${FSFW_CONFIG_PATH_ABSOLUTE}
+	${FSFW_CORE_INC_PATH}
+	${FSFW_ADD_INC_PATHS_ABS}
 )
 
 # Includes path required to compile FSFW itself as well
@@ -142,9 +175,15 @@ 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}
 )
 
 target_compile_options(${LIB_FSFW_NAME} PRIVATE 
 	${FSFW_WARNING_FLAGS}
 	${COMPILER_FLAGS}
 )
+
+target_link_libraries(${LIB_FSFW_NAME} PRIVATE
+    ${FSFW_ADDITIONAL_LINK_LIBS}
+)

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 		0
-#define	FSFW_SUBVERSION 	0
-#define	FSFW_REVISION 	1
-
-
-
-#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)
 
@@ -38,11 +38,12 @@ a starting point. The [configuration section](doc/README-config.md#top) provides
 
 [1. High-level overview](doc/README-highlevel.md#top) <br>
 [2. Core components](doc/README-core.md#top) <br>
-[3. OSAL overview](doc/README-osal.md#top) <br>
-[4. PUS services](doc/README-pus.md#top) <br>
-[5. Device Handler overview](doc/README-devicehandlers.md#top) <br>
-[6. Controller overview](doc/README-controllers.md#top) <br>
-[7. Local Data Pools](doc/README-localpools.md#top) <br>
+[3. Configuration](doc/README-config.md#top) <br>
+[4. OSAL overview](doc/README-osal.md#top) <br>
+[5. PUS services](doc/README-pus.md#top) <br>
+[6. Device Handler overview](doc/README-devicehandlers.md#top) <br>
+[7. Controller overview](doc/README-controllers.md#top) <br>
+[8. Local Data Pools](doc/README-localpools.md#top) <br>
 
 
 

action/ActionHelper.cpp

@@ -1,162 +0,0 @@
-#include "ActionHelper.h"
-#include "HasActionsIF.h"
-
-#include "../ipc/MessageQueueSenderIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-ActionHelper::ActionHelper(HasActionsIF* setOwner,
-        MessageQueueIF* useThisQueue) :
-		owner(setOwner), queueToUse(useThisQueue) {
-}
-
-ActionHelper::~ActionHelper() {
-}
-
-ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
-	if (command->getCommand() == ActionMessage::EXECUTE_ACTION) {
-		ActionId_t currentAction = ActionMessage::getActionId(command);
-		prepareExecution(command->getSender(), currentAction,
-				ActionMessage::getStoreId(command));
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return CommandMessage::UNKNOWN_COMMAND;
-	}
-}
-
-ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	if(queueToUse_ != nullptr) {
-		setQueueToUse(queueToUse_);
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
-        ActionId_t commandId, ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setStepReply(&reply, commandId, step + STEP_OFFSET, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
-        ReturnValue_t result) {
-	CommandMessage reply;
-	ActionMessage::setCompletionReply(&reply, commandId, result);
-	queueToUse->sendMessage(reportTo, &reply);
-}
-
-void ActionHelper::setQueueToUse(MessageQueueIF* queue) {
-	queueToUse = queue;
-}
-
-void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-        ActionId_t actionId, store_address_t dataAddress) {
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	if(result == HasActionsIF::EXECUTION_FINISHED) {
-		CommandMessage reply;
-		ActionMessage::setCompletionReply(&reply, actionId, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		CommandMessage reply;
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-}
-
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-		ActionId_t replyId, SerializeIF* data, bool hideSender) {
-	CommandMessage reply;
-	store_address_t storeAddress;
-	uint8_t *dataPtr;
-	size_t maxSize = data->getSerializedSize();
-	if (maxSize == 0) {
-		//No error, there's simply nothing to report.
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, maxSize,
-			&dataPtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	result = data->serialize(&dataPtr, &size, maxSize,
-	        SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeAddress);
-		return result;
-	}
-	// We don't need to report the objectId, as we receive REQUESTED data
-	// before the completion success message.
-	// True aperiodic replies need to be reported with
-	// another dedicated message.
-	ActionMessage::setDataReply(&reply, replyId, storeAddress);
-
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
-	if (hideSender) {
-		result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-	}
-	else {
-		result = queueToUse->sendMessage(reportTo, &reply);
-	}
-
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		ipcStore->deleteData(storeAddress);
-	}
-	return result;
-}
-
-void ActionHelper::resetHelper() {
-}
-
-ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo,
-        ActionId_t replyId, const uint8_t *data, size_t dataSize,
-        bool hideSender) {
-    CommandMessage reply;
-    store_address_t storeAddress;
-    ReturnValue_t result = ipcStore->addData(&storeAddress, data, dataSize);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-    }
-
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-        ipcStore->deleteData(storeAddress);
-        return result;
-    }
-
-    // We don't need to report the objectId, as we receive REQUESTED data
-    // before the completion success message.
-    // True aperiodic replies need to be reported with
-    // another dedicated message.
-    ActionMessage::setDataReply(&reply, replyId, storeAddress);
-
-    // If the sender needs to be hidden, for example to handle packet
-    // as unrequested reply, this will be done here.
-    if (hideSender) {
-        result = MessageQueueSenderIF::sendMessage(reportTo, &reply);
-    }
-    else {
-        result = queueToUse->sendMessage(reportTo, &reply);
-    }
-
-    if (result != HasReturnvaluesIF::RETURN_OK){
-        ipcStore->deleteData(storeAddress);
-    }
-    return result;
-}

action/ActionHelper.h

@@ -1,125 +0,0 @@
-#ifndef FSFW_ACTION_ACTIONHELPER_H_
-#define FSFW_ACTION_ACTIONHELPER_H_
-
-#include "ActionMessage.h"
-#include "../serialize/SerializeIF.h"
-#include "../ipc/MessageQueueIF.h"
-/**
- * @brief Action Helper is a helper class which handles action messages
- *
- * Components which use the HasActionIF this helper can be used to handle
- * the action messages.
- * It does handle step messages as well as other answers to action calls.
- * It uses the executeAction function of its owner as callback.
- * The call of the initialize function is mandatory and needs a
- * valid MessageQueueIF pointer!
- */
-class HasActionsIF;
-
-class ActionHelper {
-public:
-	/**
-	 * Constructor of the action helper
-	 * @param setOwner Pointer to the owner of the interface
-	 * @param useThisQueue  messageQueue to be used, can be set during
-	 *                      initialize function as well.
-	 */
-	ActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-
-	virtual ~ActionHelper();
-	/**
-	 * Function to be called from the owner with a new command message
-	 *
-	 * If the message is a valid action message the helper will use the
-	 * executeAction function from HasActionsIF.
-	 * If the message is invalid or the callback fails a message reply will be
-	 * send to the sender of the message automatically.
-	 *
-	 * @param command Pointer to a command message received by the owner
-	 * @return HasReturnvaluesIF::RETURN_OK if the message is a action message,
-	 *         CommandMessage::UNKNOW_COMMAND if this message ID is unkown
-	 */
-	ReturnValue_t handleActionMessage(CommandMessage* command);
-	/**
-	 * Helper initialize function. Must be called before use of any other
-	 * helper function
-	 * @param queueToUse_   Pointer to the messageQueue to be used, optional
-	 *                      if queue was set in constructor
-	 * @return Returns RETURN_OK if successful
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse_ = nullptr);
-	/**
-	 * Function to be called from the owner to send a step message.
-	 * Success or failure will be determined by the result value.
-	 *
-	 * @param step Number of steps already done
-	 * @param reportTo The messageQueueId to report the step message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void step(uint8_t step, MessageQueueId_t reportTo,
-			ActionId_t commandId,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner to send a action completion message
-	 *
-	 * @param reportTo MessageQueueId_t to report the action completion message to
-	 * @param commandId ID of the executed command
-	 * @param result Result of the execution
-	 */
-	void finish(MessageQueueId_t reportTo, ActionId_t commandId,
-	        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	/**
-	 * Function to be called by the owner if an action does report data.
-	 * Takes a SerializeIF* pointer and serializes it into the IPC store.
-	 * @param reportTo  MessageQueueId_t to report the action completion
-	 *                  message to
-	 * @param replyId ID of the executed command
-	 * @param data Pointer to the data
-	 * @return Returns RETURN_OK if successful, otherwise failure code
-	 */
-	ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
-	        SerializeIF* data, bool hideSender = false);
-    /**
-     * Function to be called by the owner if an action does report data.
-     * Takes the raw data and writes it into the IPC store.
-     * @param reportTo  MessageQueueId_t to report the action completion
-     *                  message to
-     * @param replyId ID of the executed command
-     * @param data Pointer to the data
-     * @return Returns RETURN_OK if successful, otherwise failure code
-     */
-    ReturnValue_t reportData(MessageQueueId_t reportTo, ActionId_t replyId,
-            const uint8_t* data, size_t dataSize, bool hideSender = false);
-	/**
-	 * Function to setup the MessageQueueIF* of the helper. Can be used to
-	 * set the MessageQueueIF* if message queue is unavailable at construction
-	 * and initialize but must be setup before first call of other functions.
-	 * @param queue Queue to be used by the helper
-	 */
-	void setQueueToUse(MessageQueueIF *queue);
-protected:
-	//!< Increase of value of this per step
-	static const uint8_t STEP_OFFSET = 1;
-	HasActionsIF* owner;//!< Pointer to the owner
-	//! Queue to be used as response sender, has to be set in ctor or with
-	//! setQueueToUse
-	MessageQueueIF* queueToUse;
-	//! Pointer to an IPC Store, initialized during construction or
-	StorageManagerIF* ipcStore = nullptr;
-
-	/**
-	 * Internal function called by handleActionMessage
-	 * @param commandedBy MessageQueueID of Commander
-	 * @param actionId ID of action to be done
-	 * @param dataAddress Address of additional data in IPC Store
-	 */
-	virtual void prepareExecution(MessageQueueId_t commandedBy,
-	        ActionId_t actionId, store_address_t dataAddress);
-	/**
-	 * @brief Default implementation is empty.
-	 */
-	virtual void resetHelper();
-};
-
-#endif /* FSFW_ACTION_ACTIONHELPER_H_ */

action/ActionMessage.cpp

@@ -1,81 +0,0 @@
-#include "ActionMessage.h"
-#include "HasActionsIF.h"
-
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-ActionMessage::ActionMessage() {
-}
-
-ActionMessage::~ActionMessage() {
-}
-
-void ActionMessage::setCommand(CommandMessage* message, ActionId_t fid,
-		store_address_t parameters) {
-	message->setCommand(EXECUTE_ACTION);
-	message->setParameter(fid);
-	message->setParameter2(parameters.raw);
-}
-
-ActionId_t ActionMessage::getActionId(const CommandMessage* message) {
-	return ActionId_t(message->getParameter());
-}
-
-store_address_t ActionMessage::getStoreId(const CommandMessage* message) {
-	store_address_t temp;
-	temp.raw = message->getParameter2();
-	return temp;
-}
-
-void ActionMessage::setStepReply(CommandMessage* message, ActionId_t fid, uint8_t step,
-		ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		message->setCommand(STEP_SUCCESS);
-	} else {
-		message->setCommand(STEP_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2((step << 16) + result);
-}
-
-uint8_t ActionMessage::getStep(const CommandMessage* message) {
-	return uint8_t((message->getParameter2() >> 16) & 0xFF);
-}
-
-ReturnValue_t ActionMessage::getReturnCode(const CommandMessage* message) {
-	return message->getParameter2() & 0xFFFF;
-}
-
-void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
-		store_address_t data) {
-	message->setCommand(DATA_REPLY);
-	message->setParameter(actionId);
-	message->setParameter2(data.raw);
-}
-
-void ActionMessage::setCompletionReply(CommandMessage* message,
-		ActionId_t fid, ReturnValue_t result) {
-	if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
-		message->setCommand(COMPLETION_SUCCESS);
-	} else {
-		message->setCommand(COMPLETION_FAILED);
-	}
-	message->setParameter(fid);
-	message->setParameter2(result);
-}
-
-void ActionMessage::clear(CommandMessage* message) {
-	switch(message->getCommand()) {
-	case EXECUTE_ACTION:
-	case DATA_REPLY: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
-				objects::IPC_STORE);
-		if (ipcStore != NULL) {
-			ipcStore->deleteData(getStoreId(message));
-		}
-		break;
-	}
-	default:
-		break;
-	}
-}

action/ActionMessage.h

@@ -1,43 +0,0 @@
-#ifndef FSFW_ACTION_ACTIONMESSAGE_H_
-#define FSFW_ACTION_ACTIONMESSAGE_H_
-
-#include "../ipc/CommandMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-
-using ActionId_t = uint32_t;
-
-/**
- * @brief   These messages are part of the action module of the FSFW.
- * @details
- * These messages are sent amongst objects implementing the HasActionsIF. Classes like the
- * ActionHelper are able to process these messages.
- */
-class ActionMessage {
-private:
-	ActionMessage();
-public:
-	static const uint8_t MESSAGE_ID = messagetypes::ACTION;
-	static const Command_t EXECUTE_ACTION = MAKE_COMMAND_ID(1);
-	static const Command_t STEP_SUCCESS = MAKE_COMMAND_ID(2);
-	static const Command_t STEP_FAILED = MAKE_COMMAND_ID(3);
-	static const Command_t DATA_REPLY =  MAKE_COMMAND_ID(4);
-	static const Command_t COMPLETION_SUCCESS = MAKE_COMMAND_ID(5);
-	static const Command_t COMPLETION_FAILED = MAKE_COMMAND_ID(6);
-	virtual ~ActionMessage();
-	static void setCommand(CommandMessage* message, ActionId_t fid,
-			store_address_t parameters);
-	static ActionId_t getActionId(const CommandMessage* message );
-	static store_address_t getStoreId(const CommandMessage* message );
-	static void setStepReply(CommandMessage* message, ActionId_t fid,
-			uint8_t step, ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static uint8_t getStep(const CommandMessage* message );
-	static ReturnValue_t getReturnCode(const CommandMessage* message );
-	static void setDataReply(CommandMessage* message, ActionId_t actionId,
-			store_address_t data);
-	static void setCompletionReply(CommandMessage* message, ActionId_t fid,
-			ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	static void clear(CommandMessage* message);
-};
-
-#endif /* FSFW_ACTION_ACTIONMESSAGE_H_ */

action/CMakeLists.txt

@@ -1,7 +0,0 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		ActionHelper.cpp
-		ActionMessage.cpp
-		CommandActionHelper.cpp
-		SimpleActionHelper.cpp
-)

action/CommandActionHelper.cpp

@@ -1,127 +0,0 @@
-#include "ActionMessage.h"
-#include "CommandActionHelper.h"
-#include "CommandsActionsIF.h"
-#include "HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-
-CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
-		owner(setOwner), queueToUse(NULL), ipcStore(
-		NULL), commandCount(0), lastTarget(0) {
-}
-
-CommandActionHelper::~CommandActionHelper() {
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, SerializeIF *data) {
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	uint8_t *storePointer;
-	size_t maxSize = data->getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize,
-			&storePointer);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t size = 0;
-	result = data->serialize(&storePointer, &size, maxSize,
-			SerializeIF::Endianness::BIG);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
-		ActionId_t actionId, const uint8_t *data, uint32_t size) {
-//	if (commandCount != 0) {
-//		return CommandsFunctionsIF::ALREADY_COMMANDING;
-//	}
-	HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
-	if (receiver == NULL) {
-		return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
-	}
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->addData(&storeId, data, size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return sendCommand(receiver->getCommandQueue(), actionId, storeId);
-}
-
-ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
-		ActionId_t actionId, store_address_t storeId) {
-	CommandMessage command;
-	ActionMessage::setCommand(&command, actionId, storeId);
-	ReturnValue_t result = queueToUse->sendMessage(queueId, &command);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ipcStore->deleteData(storeId);
-	}
-	lastTarget = queueId;
-	commandCount++;
-	return result;
-}
-
-ReturnValue_t CommandActionHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if (ipcStore == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	queueToUse = owner->getCommandQueuePtr();
-	if (queueToUse == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t CommandActionHelper::handleReply(CommandMessage *reply) {
-	if (reply->getSender() != lastTarget) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	switch (reply->getCommand()) {
-	case ActionMessage::COMPLETION_SUCCESS:
-		commandCount--;
-		owner->completionSuccessfulReceived(ActionMessage::getActionId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::COMPLETION_FAILED:
-		commandCount--;
-		owner->completionFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_SUCCESS:
-		owner->stepSuccessfulReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::STEP_FAILED:
-		commandCount--;
-		owner->stepFailedReceived(ActionMessage::getActionId(reply),
-				ActionMessage::getStep(reply),
-				ActionMessage::getReturnCode(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	case ActionMessage::DATA_REPLY:
-		extractDataForOwner(ActionMessage::getActionId(reply),
-				ActionMessage::getStoreId(reply));
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-uint8_t CommandActionHelper::getCommandCount() const {
-	return commandCount;
-}
-
-void CommandActionHelper::extractDataForOwner(ActionId_t actionId, store_address_t storeId) {
-	const uint8_t * data = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(storeId, &data, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return;
-	}
-	owner->dataReceived(actionId, data, size);
-	ipcStore->deleteData(storeId);
-}

action/CommandActionHelper.h

@@ -1,36 +0,0 @@
-#ifndef COMMANDACTIONHELPER_H_
-#define COMMANDACTIONHELPER_H_
-
-#include "ActionMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-class CommandsActionsIF;
-
-class CommandActionHelper {
-	friend class CommandsActionsIF;
-public:
-	CommandActionHelper(CommandsActionsIF* owner);
-	virtual ~CommandActionHelper();
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, const uint8_t* data, uint32_t size);
-	ReturnValue_t commandAction(object_id_t commandTo,
-			ActionId_t actionId, SerializeIF* data);
-	ReturnValue_t initialize();
-	ReturnValue_t handleReply(CommandMessage* reply);
-	uint8_t getCommandCount() const;
-private:
-	CommandsActionsIF* owner;
-	MessageQueueIF* queueToUse;
-	StorageManagerIF* ipcStore;
-	uint8_t commandCount;
-	MessageQueueId_t lastTarget;
-	void extractDataForOwner(ActionId_t actionId, store_address_t storeId);
-	ReturnValue_t sendCommand(MessageQueueId_t queueId, ActionId_t actionId,
-			store_address_t storeId);
-};
-
-#endif /* COMMANDACTIONHELPER_H_ */

action/CommandsActionsIF.h

@@ -1,37 +0,0 @@
-#ifndef FSFW_ACTION_COMMANDSACTIONSIF_H_
-#define FSFW_ACTION_COMMANDSACTIONSIF_H_
-
-#include "CommandActionHelper.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../ipc/MessageQueueIF.h"
-
-/**
- * Interface to separate commanding actions of other objects.
- * In next iteration, IF should be shortened to three calls:
- * - dataReceived(data)
- * - successReceived(id, step)
- * - failureReceived(id, step, cause)
- * or even
- * - replyReceived(id, step, cause) (if cause == OK, it's a success).
- */
-class CommandsActionsIF {
-	friend class CommandActionHelper;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::COMMANDS_ACTIONS_IF;
-	static const ReturnValue_t OBJECT_HAS_NO_FUNCTIONS = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t ALREADY_COMMANDING = MAKE_RETURN_CODE(2);
-	virtual ~CommandsActionsIF() {}
-	virtual MessageQueueIF* getCommandQueuePtr() = 0;
-protected:
-	virtual void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) = 0;
-	virtual void stepFailedReceived(ActionId_t actionId, uint8_t step,
-			ReturnValue_t returnCode) = 0;
-	virtual void dataReceived(ActionId_t actionId, const uint8_t* data,
-			uint32_t size) = 0;
-	virtual void completionSuccessfulReceived(ActionId_t actionId) = 0;
-	virtual void completionFailedReceived(ActionId_t actionId,
-			ReturnValue_t returnCode) = 0;
-};
-
-
-#endif /* FSFW_ACTION_COMMANDSACTIONSIF_H_ */

action/SimpleActionHelper.cpp

@@ -1,75 +0,0 @@
-#include "HasActionsIF.h"
-#include "SimpleActionHelper.h"
-
-SimpleActionHelper::SimpleActionHelper(HasActionsIF* setOwner,
-		MessageQueueIF* useThisQueue) :
-		ActionHelper(setOwner, useThisQueue), isExecuting(false) {
-}
-
-SimpleActionHelper::~SimpleActionHelper() {
-}
-
-void SimpleActionHelper::step(ReturnValue_t result) {
-	// STEP_OFFESET is subtracted to compensate for adding offset in base
-	// method, which is not necessary here.
-	ActionHelper::step(stepCount - STEP_OFFSET, lastCommander, lastAction,
-			result);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		resetHelper();
-	}
-}
-
-void SimpleActionHelper::finish(ReturnValue_t result) {
-	ActionHelper::finish(lastCommander, lastAction, result);
-	resetHelper();
-}
-
-ReturnValue_t SimpleActionHelper::reportData(SerializeIF* data) {
-	return ActionHelper::reportData(lastCommander, lastAction, data);
-}
-
-void SimpleActionHelper::resetHelper() {
-	stepCount = 0;
-	isExecuting = false;
-	lastAction = 0;
-	lastCommander = 0;
-}
-
-void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
-		ActionId_t actionId, store_address_t dataAddress) {
-	CommandMessage reply;
-	if (isExecuting) {
-		ipcStore->deleteData(dataAddress);
-		ActionMessage::setStepReply(&reply, actionId, 0,
-				HasActionsIF::IS_BUSY);
-		queueToUse->sendMessage(commandedBy, &reply);
-	}
-	const uint8_t* dataPtr = NULL;
-	size_t size = 0;
-	ReturnValue_t result = ipcStore->getData(dataAddress, &dataPtr, &size);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		return;
-	}
-	lastCommander = commandedBy;
-	lastAction = actionId;
-	result = owner->executeAction(actionId, commandedBy, dataPtr, size);
-	ipcStore->deleteData(dataAddress);
-	switch (result) {
-	case HasReturnvaluesIF::RETURN_OK:
-		isExecuting = true;
-		stepCount++;
-		break;
-	case HasActionsIF::EXECUTION_FINISHED:
-		ActionMessage::setCompletionReply(&reply, actionId,
-				HasReturnvaluesIF::RETURN_OK);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	default:
-		ActionMessage::setStepReply(&reply, actionId, 0, result);
-		queueToUse->sendMessage(commandedBy, &reply);
-		break;
-	}
-
-}

action/SimpleActionHelper.h

@@ -1,30 +0,0 @@
-#ifndef FSFW_ACTION_SIMPLEACTIONHELPER_H_
-#define FSFW_ACTION_SIMPLEACTIONHELPER_H_
-
-#include "ActionHelper.h"
-
-/**
- * @brief	This is an action helper which is only able to service one action
- * 			at a time but remembers last commander and last action which
- * 			simplifies usage
- */
-class SimpleActionHelper: public ActionHelper {
-public:
-	SimpleActionHelper(HasActionsIF* setOwner, MessageQueueIF* useThisQueue);
-	virtual ~SimpleActionHelper();
-	void step(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	void finish(ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
-	ReturnValue_t reportData(SerializeIF* data);
-
-protected:
-	void prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
-			store_address_t dataAddress);
-	virtual void resetHelper();
-private:
-	bool isExecuting;
-	MessageQueueId_t lastCommander = MessageQueueIF::NO_QUEUE;
-	ActionId_t lastAction = 0;
-	uint8_t stepCount = 0;
-};
-
-#endif /* SIMPLEACTIONHELPER_H_ */

container/ArrayList.h

@@ -1,253 +0,0 @@
-#ifndef FSFW_CONTAINER_ARRAYLIST_H_
-#define FSFW_CONTAINER_ARRAYLIST_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serialize/SerializeIF.h"
-
-/**
- * @brief 	A List that stores its values in an array.
- * @details
- * The underlying storage is an array that can be allocated by the class
- * itself or supplied via ctor.
- *
- * @ingroup container
- */
-template<typename T, typename count_t = uint8_t>
-class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
-
-	/**
-	 * This is the allocating constructor.
-	 * It allocates an array of the specified size.
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-		size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
-
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes
-	 * itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
-
-	/**
-	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
-	 * It is too ambigous in this case.
-	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
-	 */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
-
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
-
-
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
-
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator(): value(0) {}
-
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
-
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
-
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
-
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
-
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
-
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
-
-		T& operator*() {
-			return *value;
-		}
-
-		const T& operator*() const {
-			return *value;
-		}
-
-		T *operator->() {
-			return value;
-		}
-
-		const T *operator->() const {
-			return value;
-		}
-	};
-
-	friend bool operator==(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
-
-	friend bool operator!=(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
-
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
-
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
-
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
-
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
-
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
-
-	const T* back() const{
-		return &entries[size-1];
-	}
-
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	size_t maxSize() const {
-		return this->maxSize_;
-	}
-
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
-
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
-
-protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	size_t maxSize_;
-
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
-};
-
-
-
-#endif /* FSFW_CONTAINER_ARRAYLIST_H_ */

container/BinaryTree.h

@@ -1,153 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_BINARYTREE_H_
-#define FRAMEWORK_CONTAINER_BINARYTREE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <map>
-template<typename Tp>
-class BinaryNode {
-public:
-	BinaryNode(Tp* setValue) :
-			value(setValue), left(NULL), right(NULL), parent(NULL) {
-	}
-	Tp *value;
-	BinaryNode* left;
-	BinaryNode* right;
-	BinaryNode* parent;
-};
-
-template<typename Tp>
-class ExplicitNodeIterator {
-public:
-	typedef ExplicitNodeIterator<Tp> _Self;
-	typedef BinaryNode<Tp> _Node;
-	typedef Tp value_type;
-	typedef Tp* pointer;
-	typedef Tp& reference;
-	ExplicitNodeIterator() :
-			element(NULL) {
-	}
-	ExplicitNodeIterator(_Node* node) :
-			element(node) {
-	}
-	BinaryNode<Tp>* element;
-	_Self up() {
-		return _Self(element->parent);
-	}
-	_Self left() {
-		if (element != NULL) {
-			return _Self(element->left);
-		} else {
-			return _Self(NULL);
-		}
-
-	}
-	_Self right() {
-		if (element != NULL) {
-			return _Self(element->right);
-		} else {
-			return _Self(NULL);
-		}
-
-	}
-	bool operator==(const _Self& __x) const {
-		return element == __x.element;
-	}
-	bool operator!=(const _Self& __x) const {
-		return element != __x.element;
-	}
-    pointer
-    operator->() const {
-    	if (element != NULL) {
-    		return element->value;
-    	} else {
-    		return NULL;
-    	}
-    }
-    pointer operator*() const {
-    	return this->operator->();
-    }
-};
-
-/**
- * Pretty rudimentary version of a simple binary tree (not a binary search tree!).
- */
-template<typename Tp>
-class BinaryTree {
-public:
-	typedef ExplicitNodeIterator<Tp> iterator;
-	typedef BinaryNode<Tp> Node;
-	typedef std::pair<iterator, iterator> children;
-	BinaryTree() :
-			rootNode(NULL) {
-	}
-	BinaryTree(Node* rootNode) :
-			rootNode(rootNode) {
-	}
-	iterator begin() const {
-		return iterator(rootNode);
-	}
-	static iterator end() {
-		return iterator(NULL);
-	}
-	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
-		newNode->parent = parentNode.element;
-		if (parentNode.element != NULL) {
-			if (insertLeft) {
-				parentNode.element->left = newNode;
-			} else {
-				parentNode.element->right = newNode;
-			}
-		} else {
-			//Insert first element.
-			rootNode = newNode;
-		}
-		return iterator(newNode);
-	}
-	//No recursion to children. Needs to be done externally.
-	children erase(iterator node) {
-		if (node.element == rootNode) {
-			//We're root node
-			rootNode = NULL;
-		} else {
-			//Delete parent's reference
-			if (node.up().left() == node) {
-				node.up().element->left = NULL;
-			} else {
-				node.up().element->right = NULL;
-			}
-		}
-		return children(node.element->left, node.element->right);
-	}
-	static uint32_t countLeft(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.left() != end()) {
-			count++;
-			start = start.left();
-		}
-		return count;
-	}
-	static uint32_t countRight(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.right() != end()) {
-			count++;
-			start = start.right();
-		}
-		return count;
-	}
-
-protected:
-	Node* rootNode;
-};
-
-
-
-#endif /* FRAMEWORK_CONTAINER_BINARYTREE_H_ */

container/CMakeLists.txt

@@ -1,5 +0,0 @@
-target_sources(${LIB_FSFW_NAME} 
-	PRIVATE 
-		SharedRingBuffer.cpp
-		SimpleRingBuffer.cpp
-)

container/DynamicFIFO.h

@@ -1,55 +0,0 @@
-#ifndef FSFW_CONTAINER_DYNAMICFIFO_H_
-#define FSFW_CONTAINER_DYNAMICFIFO_H_
-
-#include "FIFOBase.h"
-#include <vector>
-
-/**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
- * @details
- * The maximum capacity can be determined at run-time, so this container
- * performs dynamic memory allocation!
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T>
-class DynamicFIFO: public FIFOBase<T> {
-public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
-			fifoVector(maxCapacity)  {
-		// trying to pass the pointer of the uninitialized vector
-		// to the FIFOBase constructor directly lead to a super evil bug.
-		// So we do it like this now.
-		this->setContainer(fifoVector.data());
-	};
-
-	/**
-	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong. This function allocates memory!
-	 * @details This is a very heavy operation so try to avoid this!
-	 *
-	 */
-	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
-			fifoVector(other.maxCapacity) {
-		this->fifoVector = other.fifoVector;
-		this->setContainer(fifoVector.data());
-	}
-
-	/**
-	 * @brief Custom assignment operator
-	 * @details This is a very heavy operation so try to avoid this!
-	 * @param other DyamicFIFO to copy from
-	 */
-	DynamicFIFO& operator=(const DynamicFIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoVector = other.fifoVector;
-		this->setContainer(fifoVector.data());
-		return *this;
-	}
-private:
-	std::vector<T> fifoVector;
-};
-
-#endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */

container/FIFO.h

@@ -1,47 +0,0 @@
-#ifndef FSFW_CONTAINER_FIFO_H_
-#define FSFW_CONTAINER_FIFO_H_
-
-#include "FIFOBase.h"
-#include <array>
-
-/**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
- * @details
- * Performs no dynamic memory allocation.
- * The public interface of FIFOBase exposes the user interface for the FIFO.
- * @tparam T Entry Type
- * @tparam capacity Maximum capacity
- */
-template<typename T, size_t capacity>
-class FIFO: public FIFOBase<T> {
-public:
-	FIFO(): FIFOBase<T>(nullptr, capacity) {
-		this->setContainer(fifoArray.data());
-	};
-
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-	}
-
-	/**
-	 * @brief Custom assignment operator
-	 * @param other
-	 */
-	FIFO& operator=(const FIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-		return *this;
-	}
-
-private:
-	std::array<T, capacity> fifoArray;
-};
-
-#endif /* FSFW_CONTAINER_FIFO_H_ */

container/FIFOBase.h

@@ -1,79 +0,0 @@
-#ifndef FSFW_CONTAINER_FIFOBASE_H_
-#define FSFW_CONTAINER_FIFOBASE_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-#include <cstring>
-
-template <typename T>
-class FIFOBase {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
-
-	/** Default ctor, takes pointer to first entry of underlying container
-	 *  and maximum capacity */
-	FIFOBase(T* values, const size_t maxCapacity);
-
-	/**
-	 * Insert value into FIFO
-	 * @param value
-	 * @return RETURN_OK on success, FULL if full
-	 */
-	ReturnValue_t insert(T value);
-	/**
-	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t retrieve(T *value);
-	/**
-	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t peek(T * value);
-	/**
-	 * Remove item from FIFO.
-	 * @return RETURN_OK on success, EMPTY if empty
-	 */
-	ReturnValue_t pop();
-
-	/***
-	 * Check if FIFO is empty
-	 * @return True if empty, False if not
-	 */
-	bool empty();
-	/***
-	 * Check if FIFO is Full
-	 * @return True if full, False if not
-	 */
-	bool full();
-	/***
-	 *  Current used size (elements) used
-	 * @return size_t in elements
-	 */
-	size_t size();
-	/***
-	 * Get maximal capacity of fifo
-	 * @return size_t with max capacity of this fifo
-	 */
-	size_t getMaxCapacity() const;
-
-protected:
-	void setContainer(T* data);
-	size_t maxCapacity = 0;
-
-	T* values;
-
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
-
-	size_t next(size_t current);
-};
-
-#include "FIFOBase.tpp"
-
-#endif /* FSFW_CONTAINER_FIFOBASE_H_ */

container/FIFOBase.tpp

@@ -1,93 +0,0 @@
-#ifndef FSFW_CONTAINER_FIFOBASE_TPP_
-#define FSFW_CONTAINER_FIFOBASE_TPP_
-
-#ifndef FSFW_CONTAINER_FIFOBASE_H_
-#error Include FIFOBase.h before FIFOBase.tpp!
-#endif
-
-template<typename T>
-inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		maxCapacity(maxCapacity), values(values){};
-
-template<typename T>
-inline ReturnValue_t FIFOBase<T>::insert(T value) {
-	if (full()) {
-		return FULL;
-	} else {
-		values[writeIndex] = value;
-		writeIndex = next(writeIndex);
-		++currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-template<typename T>
-inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-	if (empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		readIndex = next(readIndex);
-		--currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-template<typename T>
-inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-	if(empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-};
-
-template<typename T>
-inline ReturnValue_t FIFOBase<T>::pop() {
-	T value;
-	return this->retrieve(&value);
-};
-
-template<typename T>
-inline bool FIFOBase<T>::empty() {
-	return (currentSize == 0);
-};
-
-template<typename T>
-inline bool FIFOBase<T>::full() {
-	return (currentSize == maxCapacity);
-}
-
-template<typename T>
-inline size_t FIFOBase<T>::size() {
-	return currentSize;
-}
-
-template<typename T>
-inline size_t FIFOBase<T>::next(size_t current) {
-	++current;
-	if (current == maxCapacity) {
-		current = 0;
-	}
-	return current;
-}
-
-template<typename T>
-inline size_t FIFOBase<T>::getMaxCapacity() const {
-	return maxCapacity;
-}
-
-
-template<typename T>
-inline void FIFOBase<T>::setContainer(T *data) {
-	this->values = data;
-}
-
-#endif

container/FixedArrayList.h

@@ -1,38 +0,0 @@
-#ifndef FIXEDARRAYLIST_H_
-#define FIXEDARRAYLIST_H_
-
-#include "ArrayList.h"
-#include <cmath>
-/**
- * \ingroup container
- */
-template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
-class FixedArrayList: public ArrayList<T, count_t> {
-	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
-private:
-	T data[MAX_SIZE];
-public:
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
-
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-	}
-
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-		return *this;
-	}
-
-	virtual ~FixedArrayList() {
-	}
-
-};
-
-#endif /* FIXEDARRAYLIST_H_ */

container/FixedMap.h

@@ -1,230 +0,0 @@
-#ifndef FSFW_CONTAINER_FIXEDMAP_H_
-#define FSFW_CONTAINER_FIXEDMAP_H_
-
-#include "ArrayList.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <utility>
-#include <type_traits>
-
-/**
- * @brief    Map implementation for maps with a pre-defined size.
- * @details
- * Can be initialized with desired maximum size.
- * Iterator is used to access <key,value> pair and iterate through map entries.
- * Complexity O(n).
- * @warning Iterators return a non-const key_t in the pair.
- * @warning A User is not allowed to change the key, otherwise the map is corrupted.
- * @ingroup container
- */
-template<typename key_t, typename T>
-class FixedMap: public SerializeIF {
-	static_assert (std::is_trivially_copyable<T>::value or
-	        std::is_base_of<SerializeIF, T>::value,
-			"Types used in FixedMap must either be trivial copy-able or a "
-			"derived class from SerializeIF to be serialize-able");
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
-
-private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
-
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
-public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
-
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-	};
-
-	friend bool operator==(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
-
-	friend bool operator!=(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
-
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	uint32_t size() const {
-		return _size;
-	}
-
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != nullptr) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
-
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
-
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
-
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
-
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	bool empty() {
-	    if(_size == 0) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
-
-	bool full() {
-	    if(_size >= theMap.maxSize()) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
-
-	void clear() {
-		_size = 0;
-	}
-
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
-
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
-
-		return printSize;
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
-
-};
-
-#endif /* FSFW_CONTAINER_FIXEDMAP_H_ */

container/FixedOrderedMultimap.h

@@ -1,207 +0,0 @@
-#ifndef FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-#define FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_
-
-#include "ArrayList.h"
-#include <cstring>
-#include <functional>
-
-/**
- * @brief  An associative container which allows multiple entries of the same key.
- * @details
- * Same keys are ordered by KEY_COMPARE function which is std::less<key_t> > by default.
- *
- * It uses the ArrayList, so technically this is not a real map, it is an array of pairs
- * of type key_t, T. It is ordered by key_t as FixedMap but allows same keys. Thus it has a linear
- * complexity O(n). As long as the number of entries remains low, this
- * should not be an issue.
- * The number of insertion and deletion operation should be minimized
- * as those incur extensive memory move operations (the underlying container
- * is not node based).
- *
- * Its of fixed size so no allocations are performed after the construction.
- *
- * The maximum size is given as first parameter of the constructor.
- *
- * It provides an iterator to do list iterations.
- *
- * The type T must have a copy constructor if it is not trivial copy-able.
- *
- * @warning Iterators return a non-const key_t in the pair.
- * @warning A User is not allowed to change the key, otherwise the map is corrupted.
- *
- * \ingroup container
- */
-template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
-class FixedOrderedMultimap {
-public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
-
-	/***
-	 * Constructor which needs a size_t for the maximum allowed size
-	 *
-	 * Can not be resized during runtime
-	 *
-	 * Allocates memory at construction
-	 * @param maxSize size_t of Maximum allowed size
-	 */
-    FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
-    }
-
-	/***
-	 * Virtual destructor frees Memory by deleting its member
-	 */
-	virtual ~FixedOrderedMultimap() {
-	}
-
-	/***
-	 * Special iterator for FixedOrderedMultimap
-	 */
-	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
-	public:
-		Iterator() :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
-		}
-
-		Iterator(std::pair<key_t, T> *pair) :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
-		}
-	};
-
-	/***
-	 * Returns an iterator pointing to the first element
-	 * @return Iterator pointing to first element
-	 */
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
-
-	/**
-	 * Returns an iterator pointing to one element past the end
-	 * @return Iterator pointing to one element past the end
-	 */
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
-
-	/***
-	 * Returns the current size of the map (not maximum size!)
-	 * @return Current size
-	 */
-	size_t size() const{
-		return _size;
-	}
-
-	/**
-	 * Clears the map, does not deallocate any memory
-	 */
-	void clear(){
-		_size = 0;
-	}
-
-	/**
-	 * Returns the maximum size of the map
-	 * @return Maximum size of the map
-	 */
-	size_t maxSize() const{
-		return theMap.maxSize();
-	}
-
-	/***
-	 * Used to insert a key and value separately.
-	 *
-	 * @param[in] key Key of the new element
-	 * @param[in] value Value of the new element
-	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
-
-	/***
-	 * Used to insert new pair instead of single values
-	 *
-	 * @param pair Pair to be inserted
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(std::pair<key_t, T> pair);
-
-	/***
-	 * Can be used to check if a certain key is in the map
-	 * @param key Key to be checked
-	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
-	 */
-	ReturnValue_t exists(key_t key) const;
-
-	/***
-	 * Used to delete the element in the iterator
-	 *
-	 * The iterator will point to the element before or begin(),
-	 *  but never to one element in front of the map.
-	 *
-	 * @warning The iterator needs to be valid and dereferenceable
-	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(Iterator *iter);
-
-	/***
-	 * Used to erase by key
-	 * @param key Key to be erased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(key_t key);
-
-	/***
-	 * Find returns the first appearance of the key
-	 *
-	 * If the key does not exist, it points to end()
-	 *
-	 * @param key Key to search for
-	 * @return Iterator pointing to the first entry of key
-	 */
-	Iterator find(key_t key) const{
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	};
-
-	/***
-	 * Finds first entry of the given key and returns a
-	 * pointer to the value
-	 *
-	 * @param key Key to search for
-	 * @param value Found value
-	 * @return RETURN_OK if it points to the value,
-	 * KEY_DOES_NOT_EXIST if the key is not in the map
-	 */
-	ReturnValue_t find(key_t key, T **value) const;
-
-	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
-
-	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
-
-private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, size_t> theMap;
-	size_t _size;
-
-	size_t findFirstIndex(key_t key, size_t startAt = 0) const;
-
-	size_t findNicePlace(key_t key) const;
-
-	void removeFromPosition(size_t position);
-};
-
-#include "FixedOrderedMultimap.tpp"
-
-#endif /* FSFW_CONTAINER_FIXEDORDEREDMULTIMAP_H_ */

container/FixedOrderedMultimap.tpp

@@ -1,109 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
-#define FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_
-
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-	if (_size == theMap.maxSize()) {
-		return MAP_FULL;
-	}
-	size_t position = findNicePlace(key);
-	memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-			(_size - position) * sizeof(std::pair<key_t,T>));
-	theMap[position].first = key;
-	theMap[position].second = value;
-	++_size;
-	if (storedValue != nullptr) {
-		*storedValue = Iterator(&theMap[position]);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-	return insert(pair.first, pair.second);
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-	ReturnValue_t result = KEY_DOES_NOT_EXIST;
-	if (findFirstIndex(key) < _size) {
-		result = HasReturnvaluesIF::RETURN_OK;
-	}
-	return result;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-	size_t i;
-	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	removeFromPosition(i);
-	if (*iter != begin()) {
-		(*iter)--;
-	} else {
-		*iter = begin();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-	size_t i;
-	if ((i = findFirstIndex(key)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	do {
-		removeFromPosition(i);
-		i = findFirstIndex(key, i);
-	} while (i < _size);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-	ReturnValue_t result = exists(key);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*value = &theMap[findFirstIndex(key)].second;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-	if (startAt >= _size) {
-		return startAt + 1;
-	}
-	size_t i = startAt;
-	for (i = startAt; i < _size; ++i) {
-		if (theMap[i].first == key) {
-			return i;
-		}
-	}
-	return i;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-	size_t i = 0;
-	for (i = 0; i < _size; ++i) {
-		if (myComp(key, theMap[i].first)) {
-			return i;
-		}
-	}
-	return i;
-}
-
-template<typename key_t, typename T, typename KEY_COMPARE>
-inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-	if (_size <= position) {
-		return;
-	}
-	memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-			(_size - position - 1) * sizeof(std::pair<key_t,T>));
-	--_size;
-}
-
-
-#endif /* FRAMEWORK_CONTAINER_FIXEDORDEREDMULTIMAP_TPP_ */

container/HybridIterator.h

@@ -1,90 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
-
-#include "ArrayList.h"
-#include "SinglyLinkedList.h"
-
-template<typename T, typename count_t = uint8_t>
-class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
-public:
-	HybridIterator() {}
-
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
-
-	}
-
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
-
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
-
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
-
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
-
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
-
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
-
-	T operator*() {
-		return *value;
-	}
-
-	T *operator->() {
-		return value;
-	}
-
-	T* value = nullptr;
-
-private:
-	bool linked = false;
-	T *end = nullptr;
-};
-
-#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

container/IndexedRingMemoryArray.h

@@ -1,700 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
-
-#include "ArrayList.h"
-#include "../globalfunctions/CRC.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerialArrayListAdapter.h"
-#include <cmath>
-
-template<typename T>
-class Index: public SerializeIF{
-	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
-public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
-
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
-
-	}
-
-	void setBlockStartAddress(uint32_t newAddress){
-		this->blockStartAddress = newAddress;
-	}
-
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
-
-	const T* getIndexType() const {
-		return &indexType;
-	}
-
-	T* modifyIndexType(){
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
-
-	uint32_t getSize() const {
-		return size;
-	}
-
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
-
-	void addSize(uint32_t size){
-		this->size += size;
-	}
-
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
-
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
-
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
-
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
-
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
-
-
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
-
-private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
-};
-
-
-
-template<typename T>
-class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
-	 */
-public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
-
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
-
-		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
-
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
-
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-		//Update the totalSize for calculations
-		totalSize = useableSize;
-
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
-
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
-
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
-
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
-
-
-
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
-
-
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
-
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
-
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
-
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
-
-	/*
-	 * Reading
-	 */
-
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
-
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
-
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-
-	}
-
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
-
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
-
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}else{
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0){
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
-
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
-
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
-
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
-
-
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
-
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
-
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
-
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
-
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
-
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
-
-
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
-		return (sizeToWrite < availableSize);
-	}
-
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
-
-
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
-
-
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
-
-		uint32_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
-
-
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
-
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
-
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
-
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
-
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
-
-		return (double)filledSize/(double)this->totalSize;
-	}
-
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
-private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
-
-	//The address of the index
-	const uint32_t indexAddress;
-
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
-
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
-
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
-
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
-
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
-
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
-
-};
-
-
-
-
-#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */

container/PlacementFactory.h

@@ -1,71 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-#define FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_
-
-#include "../storagemanager/StorageManagerIF.h"
-#include <utility>
-/**
- * The Placement Factory is used to create objects at runtime in a specific pool.
- * In general, this should be avoided and it should only be used if you know what you are doing.
- * You are not allowed to use this container with a type that allocates memory internally like ArrayList.
- *
- * Also, you have to check the returned pointer in generate against nullptr!
- *
- * A backend of Type StorageManagerIF must be given as a place to store the new objects.
- * Therefore ThreadSafety is only provided by your StorageManager Implementation.
- *
- * Objects must be destroyed by the user with "destroy"! Otherwise the pool will not be cleared.
- *
- * The concept is based on the placement new operator.
- *
- * @warning Do not use with any Type that allocates memory internally!
- * @ingroup container
- */
-class PlacementFactory {
-public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
-
-	/***
-	 * Generates an object of type T in the backend storage.
-	 *
-	 * @warning Do not use with any Type that allocates memory internally!
-	 *
-	 * @tparam T Type of Object
-	 * @param args Constructor Arguments to be passed
-	 * @return A pointer to the new object or a nullptr in case of failure
-	 */
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = nullptr;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return nullptr;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	/***
-	 * Function to destroy the object allocated with generate and free space in backend.
-	 * This must be called by the user.
-	 *
-	 * @param thisElement Element to be destroyed
-	 * @return RETURN_OK if the element was destroyed, different errors on failure
-	 */
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		if (thisElement == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
-private:
-	StorageManagerIF* dataBackend;
-};
-
-#endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */

container/RingBufferBase.h

@@ -1,113 +0,0 @@
-#ifndef FSFW_CONTAINER_RINGBUFFERBASE_H_
-#define FSFW_CONTAINER_RINGBUFFERBASE_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include <cstddef>
-
-template<uint8_t N_READ_PTRS = 1>
-class RingBufferBase {
-public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
-
-	virtual ~RingBufferBase() {}
-
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
-
-	size_t getAvailableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
-
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
-
-	size_t getMaxSize() const {
-		return size - 1;
-	}
-
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
-
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
-
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
-
-	size_t getStart() const {
-		return start;
-	}
-
-protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
-
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
-
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (getAvailableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
-
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
-
-	uint32_t getWrite() const {
-		return write;
-	}
-
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
-};
-
-#endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */

container/SharedRingBuffer.cpp

@@ -1,57 +0,0 @@
-#include "SharedRingBuffer.h"
-#include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-
-SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
-}
-
-
-void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
-	this->fifoDepth = fifoDepth;
-}
-
-ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
-        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
-    return mutex->lockMutex(timeoutType, timeout);
-}
-
-ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
-    return mutex->unlockMutex();
-}
-
-
-
-MutexIF* SharedRingBuffer::getMutexHandle() const {
-    return mutex;
-}
-
-ReturnValue_t SharedRingBuffer::initialize() {
-	if(fifoDepth > 0) {
-		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
-	}
-	return SystemObject::initialize();
-}
-
-DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
-	if(receiveSizesFIFO == nullptr) {
-		// Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
-				<< " was not configured to have sizes FIFO, returning nullptr!"
-				<< std::endl;
-#endif
-	}
-	return receiveSizesFIFO;
-}

container/SharedRingBuffer.h

@@ -1,92 +0,0 @@
-#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
-#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
-
-#include "SimpleRingBuffer.h"
-#include "DynamicFIFO.h"
-#include "../ipc/MutexIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "../timemanager/Clock.h"
-
-/**
- * @brief   Ring buffer which can be shared among multiple objects
- * @details
- * This class offers a mutex to perform thread-safe operation on the ring
- * buffer. It is still up to the developer to actually perform the lock
- * and unlock operations.
- */
-class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
-public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * @brief	This function can be used to add an optional FIFO to the class
-	 * @details 
-	 * This FIFO will be allocated in the initialize function (and will
-	 * have a fixed maximum size after that). It can be used to store
-	 * values like packet sizes, for example for a shared ring buffer
-	 * used by producer/consumer tasks.
-	 */
-	void setToUseReceiveSizeFIFO(size_t fifoDepth);
-
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
-
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
-
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
-
-	ReturnValue_t initialize() override;
-
-	/**
-	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
-	 * to that FIFO can be retrieved with this function.
-	 * Do not forget to protect access with a lock if required!
-	 * @return
-	 */
-	DynamicFIFO<size_t>* getReceiveSizesFIFO();
-private:
-	MutexIF* mutex = nullptr;
-
-	size_t fifoDepth = 0;
-	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
-};
-
-
-
-#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

container/SimpleRingBuffer.cpp

@@ -1,131 +0,0 @@
-#include "SimpleRingBuffer.h"
-#include <cstring>
-
-SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
-}
-
-SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-        RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-}
-
-SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
-}
-
-ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
-        size_t amount) {
-    if (availableWriteSpace() >= amount or overwriteOld) {
-        size_t amountTillWrap = writeTillWrap();
-        if (amountTillWrap < amount) {
-            if((amount - amountTillWrap + excessBytes) > maxExcessBytes) {
-                return HasReturnvaluesIF::RETURN_FAILED;
-            }
-            excessBytes = amount - amountTillWrap;
-        }
-        *writePointer = &buffer[write];
-        return HasReturnvaluesIF::RETURN_OK;
-    }
-    else {
-        return HasReturnvaluesIF::RETURN_FAILED;
-    }
-}
-
-void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
-	if(getExcessBytes() > 0) {
-		moveExcessBytesToStart();
-	}
-	incrementWrite(amount);
-
-}
-
-ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
-
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-size_t SimpleRingBuffer::getExcessBytes() const {
-    return excessBytes;
-}
-
-void SimpleRingBuffer::moveExcessBytesToStart() {
-    if(excessBytes > 0) {
-        std::memcpy(buffer, &buffer[size], excessBytes);
-        excessBytes = 0;
-    }
-}
-
-ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
-}

container/SimpleRingBuffer.h

@@ -1,129 +0,0 @@
-#ifndef FSFW_CONTAINER_SIMPLERINGBUFFER_H_
-#define FSFW_CONTAINER_SIMPLERINGBUFFER_H_
-
-#include "RingBufferBase.h"
-#include <cstddef>
-
-/**
- * @brief 	Circular buffer implementation, useful for buffering
- *          into data streams.
- * @details
- * Note that the deleteData() has to be called to increment the read pointer.
- * This class allocated dynamically, so
- * @ingroup containers
- */
-class SimpleRingBuffer: public RingBufferBase<> {
-public:
-    /**
-     * This constructor allocates a new internal buffer with the supplied size.
-     *
-     * @param size
-     * @param overwriteOld If the ring buffer is overflowing at a write
-     * operation, the oldest data will be overwritten.
-     * @param maxExcessBytes These additional bytes will be allocated in addtion
-     * to the specified size to accomodate contiguous write operations
-     * with getFreeElement.
-     *
-     */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-     * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-
-	virtual ~SimpleRingBuffer();
-
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
-
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached. This function
-	 * does not increment the write pointer!
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
-
-	/**
-	 * This increments the write pointer and also copies the excess bytes
-	 * to the beginning. It should be called if the write operation
-	 * conducted after calling getFreeElement() was performed.
-	 * @return
-	 */
-	void confirmBytesWritten(size_t amount);
-
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
-
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
-
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
-
-private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
-};
-
-#endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
-

container/SinglyLinkedList.h

@@ -1,154 +0,0 @@
-#ifndef FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
-#define FRAMEWORK_CONTAINER_SINGLYLINKEDLIST_H_
-
-#include <cstddef>
-#include <cstdint>
-
-/**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
- * @ingroup container
- */
-template<typename T>
-class LinkedElement {
-public:
-	T *value;
-	class Iterator {
-	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
-
-		Iterator(LinkedElement<T> *element) :
-				value(element) {
-		}
-
-		Iterator& operator++() {
-			value = value->getNext();
-			return *this;
-		}
-
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
-
-		bool operator==(Iterator other) {
-			return value == other.value;
-		}
-
-		bool operator!=(Iterator other) {
-			return !(*this == other);
-		}
-		T *operator->() {
-			return value->value;
-		}
-	};
-
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
-
-	virtual ~LinkedElement(){}
-
-	virtual LinkedElement* getNext() const {
-		return next;
-	}
-
-	virtual void setNext(LinkedElement* next) {
-		this->next = next;
-	}
-
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
-
-	LinkedElement* begin() {
-		return this;
-	}
-	LinkedElement* end() {
-		return nullptr;
-	}
-private:
-	LinkedElement *next;
-};
-
-template<typename T>
-class SinglyLinkedList {
-public:
-    using ElementIterator = typename LinkedElement<T>::Iterator;
-
-	SinglyLinkedList() {}
-
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
-
-	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
-
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
-	}
-
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
-
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element->getNext() != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
-
-	size_t getSize() const {
-		size_t size = 0;
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			size++;
-			element = element->getNext();
-		}
-		return size;
-	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
-	}
-
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
-
-    void setLast(LinkedElement<T>* lastElement) {
-        lastElement->setEnd();
-    }
-
-    void insertElement(LinkedElement<T>* element, size_t position) {
-        LinkedElement<T> *currentElement = start;
-        for(size_t count = 0; count < position; count++) {
-            if(currentElement == nullptr) {
-                return;
-            }
-            currentElement = currentElement->getNext();
-        }
-        LinkedElement<T>* elementAfterCurrent = currentElement->next;
-        currentElement->setNext(element);
-        if(elementAfterCurrent != nullptr) {
-            element->setNext(elementAfterCurrent);
-        }
-    }
-
-    void insertBack(LinkedElement<T>* lastElement) {
-        back().value->setNext(lastElement);
-    }
-
-protected:
-	LinkedElement<T> *start = nullptr;
-};
-
-#endif /* SINGLYLINKEDLIST_H_ */

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()

controller/CMakeLists.txt

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

controller/ControllerBase.cpp

@@ -1,137 +0,0 @@
-#include "ControllerBase.h"
-
-#include "../subsystem/SubsystemBase.h"
-#include "../ipc/QueueFactory.h"
-#include "../action/HasActionsIF.h"
-
-ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
-		size_t commandQueueDepth) :
-		SystemObject(setObjectId), parentId(parentId), mode(MODE_OFF),
-		submode(SUBMODE_NONE), modeHelper(this),
-		healthHelper(this, setObjectId) {
-	commandQueue = QueueFactory::instance()->createMessageQueue(
-	        commandQueueDepth);
-}
-
-ControllerBase::~ControllerBase() {
-	QueueFactory::instance()->deleteMessageQueue(commandQueue);
-}
-
-ReturnValue_t ControllerBase::initialize() {
-	ReturnValue_t result = SystemObject::initialize();
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	MessageQueueId_t parentQueue = 0;
-	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
-		if (parent == nullptr) {
-			return RETURN_FAILED;
-		}
-		parentQueue = parent->getCommandQueue();
-
-		parent->registerChild(getObjectId());
-	}
-
-	result = healthHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	result = modeHelper.initialize(parentQueue);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	return RETURN_OK;
-}
-
-MessageQueueId_t ControllerBase::getCommandQueue() const {
-	return commandQueue->getId();
-}
-
-void ControllerBase::handleQueue() {
-	CommandMessage command;
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	for (result = commandQueue->receiveMessage(&command);
-	        result == RETURN_OK;
-			result = commandQueue->receiveMessage(&command)) {
-
-		result = modeHelper.handleModeCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-
-		result = healthHelper.handleHealthCommand(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		result = handleCommandMessage(&command);
-		if (result == RETURN_OK) {
-			continue;
-		}
-		command.setToUnknownCommand();
-		commandQueue->reply(&command);
-	}
-
-}
-
-void ControllerBase::startTransition(Mode_t mode, Submode_t submode) {
-	changeHK(this->mode, this->submode, false);
-	triggerEvent(CHANGING_MODE, mode, submode);
-	this->mode = mode;
-	this->submode = submode;
-	modeHelper.modeChanged(mode, submode);
-	modeChanged(mode, submode);
-	announceMode(false);
-	changeHK(this->mode, this->submode, true);
-}
-
-void ControllerBase::getMode(Mode_t* mode, Submode_t* submode) {
-	*mode = this->mode;
-	*submode = this->submode;
-}
-
-void ControllerBase::setToExternalControl() {
-	healthHelper.setHealth(EXTERNAL_CONTROL);
-}
-
-void ControllerBase::announceMode(bool recursive) {
-	triggerEvent(MODE_INFO, mode, submode);
-}
-
-ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
-	handleQueue();
-	performControlOperation();
-	return RETURN_OK;
-}
-
-void ControllerBase::modeChanged(Mode_t mode, Submode_t submode) {
-	return;
-}
-
-ReturnValue_t ControllerBase::setHealth(HealthState health) {
-	switch (health) {
-	case HEALTHY:
-	case EXTERNAL_CONTROL:
-		healthHelper.setHealth(health);
-		return RETURN_OK;
-	default:
-		return INVALID_HEALTH_STATE;
-	}
-}
-
-HasHealthIF::HealthState ControllerBase::getHealth() {
-	return healthHelper.getHealth();
-}
-void ControllerBase::setTaskIF(PeriodicTaskIF* task_){
-			executingTask = task_;
-}
-
-void ControllerBase::changeHK(Mode_t mode, Submode_t submode, bool enable) {
-}
-
-ReturnValue_t ControllerBase::initializeAfterTaskCreation() {
-    return HasReturnvaluesIF::RETURN_OK;
-}

controller/ControllerBase.h

@@ -1,94 +0,0 @@
-#ifndef FSFW_CONTROLLER_CONTROLLERBASE_H_
-#define FSFW_CONTROLLER_CONTROLLERBASE_H_
-
-#include "../health/HasHealthIF.h"
-#include "../health/HealthHelper.h"
-#include "../modes/HasModesIF.h"
-#include "../modes/ModeHelper.h"
-#include "../objectmanager/SystemObject.h"
-#include "../tasks/ExecutableObjectIF.h"
-#include "../tasks/PeriodicTaskIF.h"
-#include "../datapool/HkSwitchHelper.h"
-
-/**
- * @brief   Generic base class for controller classes
- * @details
- * Implements common interfaces for controllers, which generally have
- * a mode and a health state. This avoids boilerplate code.
- */
-class ControllerBase: public HasModesIF,
-		public HasHealthIF,
-		public ExecutableObjectIF,
-		public SystemObject,
-		public HasReturnvaluesIF {
-public:
-	static const Mode_t MODE_NORMAL = 2;
-
-	ControllerBase(object_id_t setObjectId, object_id_t parentId,
-			size_t commandQueueDepth = 3);
-	virtual ~ControllerBase();
-
-	/** SystemObject override */
-	virtual ReturnValue_t initialize() override;
-
-	virtual MessageQueueId_t getCommandQueue() const override;
-
-	/** HasHealthIF overrides */
-	virtual ReturnValue_t setHealth(HealthState health) override;
-	virtual HasHealthIF::HealthState getHealth() override;
-
-	/** ExecutableObjectIF overrides */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
-	virtual ReturnValue_t initializeAfterTaskCreation() override;
-
-protected:
-
-	/**
-	 * Implemented by child class. Handle command messages which are not
-	 * mode or health messages.
-	 * @param message
-	 * @return
-	 */
-    virtual ReturnValue_t handleCommandMessage(CommandMessage *message) = 0;
-
-    /**
-     * Periodic helper, implemented by child class.
-     */
-    virtual void performControlOperation() = 0;
-
-    virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
-            uint32_t *msToReachTheMode) = 0;
-
-	const object_id_t parentId;
-
-	Mode_t mode;
-
-	Submode_t submode;
-
-	MessageQueueIF* commandQueue = nullptr;
-
-	ModeHelper modeHelper;
-
-	HealthHelper healthHelper;
-
-	/**
-	 * Pointer to the task which executes this component,
-	 * is invalid before setTaskIF was called.
-	 */
-	PeriodicTaskIF* executingTask = nullptr;
-
-	/** Handle mode and health messages */
-	virtual void handleQueue();
-
-	/** Mode helpers */
-	virtual void modeChanged(Mode_t mode, Submode_t submode);
-	virtual void startTransition(Mode_t mode, Submode_t submode);
-	virtual void getMode(Mode_t *mode, Submode_t *submode);
-	virtual void setToExternalControl();
-	virtual void announceMode(bool recursive);
-	/** HK helpers */
-	virtual void changeHK(Mode_t mode, Submode_t submode, bool enable);
-};
-
-#endif /* FSFW_CONTROLLER_CONTROLLERBASE_H_ */

datapool/PoolDataSetBase.cpp

@@ -1,230 +0,0 @@
-#include "PoolDataSetBase.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
-
-PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-        const size_t maxFillCount):
-        registeredVariables(registeredVariablesArray),
-        maxFillCount(maxFillCount) {
-}
-
-PoolDataSetBase::~PoolDataSetBase() {}
-
-
-ReturnValue_t PoolDataSetBase::registerVariable(
-		PoolVariableIF *variable) {
-	if (state != States::STATE_SET_UNINITIALISED) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"Call made in wrong position." << std::endl;
-#endif
-		return DataSetIF::DATA_SET_UNINITIALISED;
-	}
-	if (variable == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"Pool variable is nullptr." << std::endl;
-#endif
-		return DataSetIF::POOL_VAR_NULL;
-	}
-	if (fillCount >= maxFillCount) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::registerVariable: "
-				"DataSet is full." << std::endl;
-#endif
-		return DataSetIF::DATA_SET_FULL;
-	}
-	registeredVariables[fillCount] = variable;
-	fillCount++;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PoolDataSetBase::read(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	ReturnValue_t error = result;
-	if (state == States::STATE_SET_UNINITIALISED) {
-		lockDataPool(timeoutType, lockTimeout);
-		for (uint16_t count = 0; count < fillCount; count++) {
-			result = readVariable(count);
-			if(result != RETURN_OK) {
-				error = result;
-			}
-		}
-		state = States::STATE_SET_WAS_READ;
-		unlockDataPool();
-	}
-	else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "DataSet::read(): "
-				"Call made in wrong position. Don't forget to commit"
-				" member datasets!" << std::endl;
-#endif
-		result = SET_WAS_ALREADY_READ;
-	}
-
-	if(error != HasReturnvaluesIF::RETURN_OK) {
-		result = error;
-	}
-	return result;
-}
-
-uint16_t PoolDataSetBase::getFillCount() const {
-    return fillCount;
-}
-
-ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	if(registeredVariables[count] == nullptr) {
-	    // configuration error.
-	    return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-	// These checks are often performed by the respective
-	// variable implementation too, but I guess a double check does not hurt.
-	if (registeredVariables[count]->getReadWriteMode() !=
-				PoolVariableIF::VAR_WRITE and
-		registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER)
-	{
-		if(protectEveryReadCommitCall) {
-			result = registeredVariables[count]->read(
-					timeoutTypeForSingleVars,
-					mutexTimeoutForSingleVars);
-		}
-		else {
-			result = registeredVariables[count]->readWithoutLock();
-		}
-
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			result = INVALID_PARAMETER_DEFINITION;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t PoolDataSetBase::commit(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	if (state == States::STATE_SET_WAS_READ) {
-		handleAlreadyReadDatasetCommit(timeoutType, lockTimeout);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return handleUnreadDatasetCommit(timeoutType, lockTimeout);
-	}
-}
-
-void PoolDataSetBase::handleAlreadyReadDatasetCommit(
-		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
-	lockDataPool(timeoutType, lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				!= PoolVariableIF::VAR_READ
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if(protectEveryReadCommitCall) {
-				registeredVariables[count]->commit(
-						timeoutTypeForSingleVars,
-						mutexTimeoutForSingleVars);
-			}
-			else {
-				registeredVariables[count]->commitWithoutLock();
-			}
-		}
-	}
-	state = States::STATE_SET_UNINITIALISED;
-	unlockDataPool();
-}
-
-ReturnValue_t PoolDataSetBase::handleUnreadDatasetCommit(
-		MutexIF::TimeoutType timeoutType, uint32_t lockTimeout) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	lockDataPool(timeoutType, lockTimeout);
-	for (uint16_t count = 0; count < fillCount; count++) {
-		if (registeredVariables[count]->getReadWriteMode()
-				== PoolVariableIF::VAR_WRITE
-				&& registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if(protectEveryReadCommitCall) {
-				result = registeredVariables[count]->commit(
-						timeoutTypeForSingleVars,
-						mutexTimeoutForSingleVars);
-			}
-			else {
-				result = registeredVariables[count]->commitWithoutLock();
-			}
-
-		} else if (registeredVariables[count]->getDataPoolId()
-				!= PoolVariableIF::NO_PARAMETER) {
-			if (result != COMMITING_WITHOUT_READING) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-				sif::error << "DataSet::commit(): commit-without-read call made "
-						"with non write-only variable." << std::endl;
-#endif
-				result = COMMITING_WITHOUT_READING;
-			}
-		}
-	}
-	state = States::STATE_SET_UNINITIALISED;
-	unlockDataPool();
-	return result;
-}
-
-
-ReturnValue_t PoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
-		uint32_t lockTimeout) {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PoolDataSetBase::unlockDataPool() {
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PoolDataSetBase::serialize(uint8_t** buffer, size_t* size,
-		const size_t maxSize, SerializeIF::Endianness streamEndianness) const {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->serialize(buffer, size, maxSize,
-		        streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-ReturnValue_t PoolDataSetBase::deSerialize(const uint8_t** buffer, size_t* size,
-        SerializeIF::Endianness streamEndianness) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		result = registeredVariables[count]->deSerialize(buffer, size,
-				streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-	}
-	return result;
-}
-
-size_t PoolDataSetBase::getSerializedSize() const {
-	uint32_t size = 0;
-	for (uint16_t count = 0; count < fillCount; count++) {
-		size += registeredVariables[count]->getSerializedSize();
-	}
-	return size;
-}
-
-void PoolDataSetBase::setContainer(PoolVariableIF **variablesContainer) {
-    this->registeredVariables = variablesContainer;
-}
-
-PoolVariableIF** PoolDataSetBase::getContainer() const {
-	return registeredVariables;
-}
-
-void PoolDataSetBase::setReadCommitProtectionBehaviour(
-		bool protectEveryReadCommit, MutexIF::TimeoutType timeoutType,
-		uint32_t mutexTimeout) {
-	this->protectEveryReadCommitCall = protectEveryReadCommit;
-	this->timeoutTypeForSingleVars = timeoutType;
-	this->mutexTimeoutForSingleVars = mutexTimeout;
-}

datapool/PoolDataSetBase.h

@@ -1,177 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
-#define FSFW_DATAPOOL_POOLDATASETBASE_H_
-
-#include "PoolDataSetIF.h"
-#include "PoolVariableIF.h"
-#include "../serialize/SerializeIF.h"
-#include "../ipc/MutexIF.h"
-
-/**
- * @brief	The DataSetBase class manages a set of locally checked out variables.
- * @details
- * This class manages a list, where a set of local variables (or pool variables)
- * are registered. They are checked-out (i.e. their values are looked
- * up and copied) with the read call. After the user finishes working with the
- * pool variables, he can write back all variable values to the pool with
- * the commit call. The data set manages locking and freeing the data pool,
- * to ensure that all values are read and written back at once.
- *
- * An internal state manages usage of this class. Variables may only be
- * registered before the read call is made, and the commit call only
- * after the read call.
- *
- * If pool variables are writable and not committed until destruction
- * of the set, the DataSet class automatically sets the valid flag in the
- * data pool to invalid (without) changing the variable's value.
- *
- * The base class lockDataPool und unlockDataPool implementation are empty
- * and should be implemented to protect the underlying pool type.
- * @author	Bastian Baetz
- * @ingroup data_pool
- */
-class PoolDataSetBase: public PoolDataSetIF,
-		public SerializeIF,
-		public HasReturnvaluesIF {
-public:
-
-	/**
-	 * @brief	Creates an empty dataset. Use registerVariable or
-	 * 			supply a pointer to this dataset to PoolVariable
-	 * 			initializations to register pool variables.
-	 */
-	PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
-	        const size_t maxFillCount);
-	virtual~ PoolDataSetBase();
-
-	/**
-	 * @brief	The read call initializes reading out all registered variables.
-	 * 			It is mandatory to call commit after every read call!
-	 * @details
-	 * It iterates through the list of registered variables and calls all read()
-	 * functions of the registered pool variables (which read out their values
-	 * from the data pool) which are not write-only.
-	 * In case of an error (e.g. a wrong data type, or an invalid data pool id),
-	 * the operation is aborted and @c INVALID_PARAMETER_DEFINITION returned.
-	 *
-	 * The data pool is locked during the whole read operation and
-	 * freed afterwards. It is mandatory to call commit after a read call,
-	 * even if the read operation is not successful!
-	 * @return
-	 * - @c RETURN_OK if all variables were read successfully.
-	 * - @c INVALID_PARAMETER_DEFINITION if a pool entry does not exist or there
-	 *      is a type conflict.
-	 * - @c SET_WAS_ALREADY_READ if read() is called twice without calling
-	 *      commit() in between
-	 */
-	virtual ReturnValue_t read(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t lockTimeout = 20) override;
-	/**
-	 * @brief	The commit call initializes writing back the registered variables.
-	 * @details
-	 * It iterates through the list of registered variables and calls the
-	 * commit() method of the remaining registered variables (which write back
-	 * their values to the pool).
-	 *
-	 * The data pool is locked during the whole commit operation and
-	 * freed afterwards. The state changes to "was committed" after this operation.
-	 *
-	 * If the set does contain at least one variable which is not write-only
-	 * commit() can only be called after read(). If the set only contains
-	 * variables which are write only, commit() can be called without a
-	 * preceding read() call. Every read call must be followed by a commit call!
-	 * @return	- @c RETURN_OK if all variables were read successfully.
-	 * 			- @c COMMITING_WITHOUT_READING if set was not read yet and
-	 * 			  contains non write-only variables
-	 */
-	virtual ReturnValue_t commit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t lockTimeout = 20) override;
-
-	/**
-	 * Register the passed pool variable instance into the data set.
-	 * @param variable
-	 * @return
-	 */
-	virtual ReturnValue_t registerVariable( PoolVariableIF* variable) override;
-
-	/**
-	 * Provides the means to lock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t lockDataPool(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20) override;
-	/**
-	 * Provides the means to unlock the underlying data structure to ensure
-	 * thread-safety. Default implementation is empty
-	 * @return Always returns -@c RETURN_OK
-	 */
-	virtual ReturnValue_t unlockDataPool() override;
-
-	virtual uint16_t getFillCount() const;
-
-	/* SerializeIF implementations */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				const size_t maxSize,
-				SerializeIF::Endianness streamEndianness) const override;
-	virtual size_t getSerializedSize() const override;
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override;
-
-    /**
-     * Can be used to individually protect every read and commit call.
-     * @param protectEveryReadCommit
-     * @param mutexTimeout
-     */
-    void setReadCommitProtectionBehaviour(bool protectEveryReadCommit,
-            MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-            uint32_t mutexTimeout = 20);
-protected:
-
-	/**
-	 * @brief	The fill_count attribute ensures that the variables
-	 * 			register in the correct array position and that the maximum
-	 * 			number of variables is not exceeded.
-	 */
-	uint16_t fillCount = 0;
-	/**
-	 * States of the seet.
-	 */
-	enum class States {
-		STATE_SET_UNINITIALISED, //!< DATA_SET_UNINITIALISED
-		STATE_SET_WAS_READ     //!< DATA_SET_WAS_READ
-	};
-	/**
-	 * @brief	state manages the internal state of the data set,
-	 *          which is important e.g. for the behavior on destruction.
-	 */
-	States state = States::STATE_SET_UNINITIALISED;
-
-	/**
-	 * @brief	This array represents all pool variables registered in this set.
-	 * Child classes can use a static or dynamic container to create
-	 * an array of registered variables and assign the first entry here.
-	 */
-	PoolVariableIF** registeredVariables = nullptr;
-	const size_t maxFillCount = 0;
-
-	void setContainer(PoolVariableIF** variablesContainer);
-	PoolVariableIF** getContainer() const;
-
-private:
-	bool protectEveryReadCommitCall = false;
-	MutexIF::TimeoutType timeoutTypeForSingleVars = MutexIF::TimeoutType::WAITING;
-	uint32_t mutexTimeoutForSingleVars = 20;
-
-	ReturnValue_t readVariable(uint16_t count);
-	void handleAlreadyReadDatasetCommit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
-	ReturnValue_t handleUnreadDatasetCommit(
-			MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-			uint32_t timeoutMs = 20);
-};
-
-#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */

datapool/PoolVariableIF.h

@@ -1,66 +0,0 @@
-#ifndef FSFW_DATAPOOL_POOLVARIABLEIF_H_
-#define FSFW_DATAPOOL_POOLVARIABLEIF_H_
-
-#include "../returnvalues/HasReturnvaluesIF.h"
-#include "../serialize/SerializeIF.h"
-#include "ReadCommitIF.h"
-
-/**
- * @brief	This interface is used to control data pool
- * 			variable representations.
- * @details
- * To securely handle data pool variables, all pool entries are locally
- * managed by data pool variable access classes, which are called pool
- * variables. To ensure a common state of a set of variables needed in a
- * function, these local pool variables again are managed by other classes,
- * like the DataSet classes. This interface provides unified access to
- * local pool variables for such manager classes.
- * @author 	Bastian Baetz
- * @ingroup data_pool
- */
-class PoolVariableIF : public SerializeIF,
-		public ReadCommitIF {
-	friend class PoolDataSetBase;
-	friend class LocalPoolDataSetBase;
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
-	static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
-	static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
-
-	static constexpr bool VALID = 1;
-	static constexpr bool INVALID = 0;
-	static constexpr uint32_t NO_PARAMETER = 0xffffffff;
-
-	enum ReadWriteMode_t {
-		VAR_READ, VAR_WRITE, VAR_READ_WRITE
-	};
-
-	/**
-	 * @brief	This is an empty virtual destructor,
-	 * 			as it is proposed for C++ interfaces.
-	 */
-	virtual ~PoolVariableIF() {}
-	/**
-	 * @brief	This method returns if the variable is write-only,
-	 * 			read-write or read-only.
-	 */
-	virtual ReadWriteMode_t getReadWriteMode() const = 0;
-	/**
-	 * @brief	This operation shall return the data pool id of the variable.
-	 */
-	virtual uint32_t getDataPoolId() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the
-	 * 			variable is returned.
-	 */
-	virtual bool isValid() const = 0;
-	/**
-	 * @brief	With this call, the valid information of the variable is set.
-	 */
-	virtual void setValid(bool validity) = 0;
-
-};
-
-using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
-
-#endif /* FSFW_DATAPOOL_POOLVARIABLEIF_H_ */

datapoollocal/LocalDataPoolManager.cpp

@@ -1,911 +0,0 @@
-#include "HasLocalDataPoolIF.h"
-#include "LocalDataPoolManager.h"
-#include "LocalPoolObjectBase.h"
-#include "LocalPoolDataSetBase.h"
-#include "internal/LocalPoolDataSetAttorney.h"
-#include "internal/HasLocalDpIFManagerAttorney.h"
-
-#include "../housekeeping/HousekeepingPacketUpdate.h"
-#include "../housekeeping/HousekeepingSetPacket.h"
-#include "../housekeeping/AcceptsHkPacketsIF.h"
-#include "../timemanager/CCSDSTime.h"
-#include "../ipc/MutexFactory.h"
-#include "../ipc/MutexHelper.h"
-#include "../ipc/QueueFactory.h"
-
-#include <array>
-#include <cmath>
-
-object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
-
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-		bool appendValidityBuffer):
-		appendValidityBuffer(appendValidityBuffer) {
-	if(owner == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
-				"Invalid supplied owner");
-		return;
-	}
-	this->owner = owner;
-	mutex = MutexFactory::instance()->createMutex();
-	if(mutex == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR,
-				"LocalDataPoolManager", HasReturnvaluesIF::RETURN_FAILED,
-				"Could not create mutex");
-	}
-
-	hkQueue = queueToUse;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {}
-
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-	if(queueToUse == nullptr) {
-		// error, all destinations invalid
-		printWarningOrError(sif::OutputTypes::OUT_ERROR,
-				"initialize", QUEUE_OR_DESTINATION_INVALID);
-	}
-	hkQueue = queueToUse;
-
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
-	if(ipcStore == nullptr) {
-		// error, all destinations invalid
-		printWarningOrError(sif::OutputTypes::OUT_ERROR,
-				"initialize", HasReturnvaluesIF::RETURN_FAILED,
-				"Could not set IPC store.");
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-
-
-	if(defaultHkDestination != objects::NO_OBJECT) {
-		AcceptsHkPacketsIF* hkPacketReceiver =
-				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
-		if(hkPacketReceiver != nullptr) {
-			hkDestinationId = hkPacketReceiver->getHkQueue();
-		}
-		else {
-			printWarningOrError(sif::OutputTypes::OUT_ERROR,
-					"initialize", QUEUE_OR_DESTINATION_INVALID);
-			return QUEUE_OR_DESTINATION_INVALID;
-		}
-	}
-
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(
-		uint8_t nonDiagInvlFactor) {
-	setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
-	return initializeHousekeepingPoolEntriesOnce();
-}
-
-ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-	if(not mapInitialized) {
-		ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap,
-				*this);
-		if(result == HasReturnvaluesIF::RETURN_OK) {
-			mapInitialized = true;
-		}
-		return result;
-	}
-
-	printWarningOrError(sif::OutputTypes::OUT_WARNING,
-			"initialize", HasReturnvaluesIF::RETURN_FAILED,
-			"The map should only be initialized once");
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-	ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
-	for(auto& receiver: hkReceiversMap) {
-		switch(receiver.reportingType) {
-		case(ReportingType::PERIODIC): {
-			if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-				// Periodic packets shall only be generated from datasets.
-				continue;
-			}
-			performPeriodicHkGeneration(receiver);
-			break;
-		}
-		case(ReportingType::UPDATE_HK): {
-			handleHkUpdate(receiver, status);
-			break;
-		}
-		case(ReportingType::UPDATE_NOTIFICATION): {
-			handleNotificationUpdate(receiver, status);
-			break;
-		}
-		case(ReportingType::UPDATE_SNAPSHOT): {
-			handleNotificationSnapshot(receiver, status);
-			break;
-		}
-		default:
-			// This should never happen.
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	resetHkUpdateResetHelper();
-	return status;
-}
-
-ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver,
-		ReturnValue_t& status) {
-	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		// Update packets shall only be generated from datasets.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
-			receiver.dataId.sid);
-	if(dataSet->hasChanged()) {
-		// prepare and send update notification
-		ReturnValue_t result = generateHousekeepingPacket(
-				receiver.dataId.sid, dataSet, true);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-		}
-	}
-	handleChangeResetLogic(receiver.dataType, receiver.dataId,
-			dataSet);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
-		ReturnValue_t& status) {
-	MarkChangedIF* toReset = nullptr;
-	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
-				receiver.dataId.localPoolId);
-		//LocalPoolObjectBase* poolObj = owner->getPoolObjectHandle(receiver.dataId.localPoolId);
-		if(poolObj == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"handleNotificationUpdate", POOLOBJECT_NOT_FOUND);
-			return POOLOBJECT_NOT_FOUND;
-		}
-		if(poolObj->hasChanged()) {
-			// prepare and send update notification.
-			CommandMessage notification;
-			HousekeepingMessage::setUpdateNotificationVariableCommand(&notification,
-					receiver.dataId.localPoolId);
-			ReturnValue_t result = hkQueue->sendMessage(
-					receiver.destinationQueue, &notification);
-			if(result != HasReturnvaluesIF::RETURN_OK) {
-				status = result;
-			}
-			toReset = poolObj;
-		}
-
-	}
-	else {
-		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
-				receiver.dataId.sid);
-		if(dataSet == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"handleNotificationUpdate", DATASET_NOT_FOUND);
-			return DATASET_NOT_FOUND;
-		}
-		if(dataSet->hasChanged()) {
-			// prepare and send update notification
-			CommandMessage notification;
-			HousekeepingMessage::setUpdateNotificationSetCommand(
-					&notification, receiver.dataId.sid);
-			ReturnValue_t result = hkQueue->sendMessage(
-					receiver.destinationQueue, &notification);
-			if(result != HasReturnvaluesIF::RETURN_OK) {
-				status = result;
-			}
-			toReset = dataSet;
-		}
-	}
-	if(toReset != nullptr) {
-		handleChangeResetLogic(receiver.dataType,
-				receiver.dataId, toReset);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(
-		HkReceiver& receiver, ReturnValue_t& status) {
-	MarkChangedIF* toReset = nullptr;
-	// check whether data has changed and send messages in case it has.
-	if(receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-		LocalPoolObjectBase* poolObj = HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
-				receiver.dataId.localPoolId);
-		if(poolObj == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"handleNotificationSnapshot", POOLOBJECT_NOT_FOUND);
-			return POOLOBJECT_NOT_FOUND;
-		}
-
-		if (not poolObj->hasChanged()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-
-		// prepare and send update snapshot.
-		timeval now;
-		Clock::getClock_timeval(&now);
-		CCSDSTime::CDS_short cds;
-		CCSDSTime::convertToCcsds(&cds, &now);
-		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner,
-						receiver.dataId.localPoolId));
-
-		store_address_t storeId;
-		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		CommandMessage notification;
-		HousekeepingMessage::setUpdateSnapshotVariableCommand(&notification,
-				receiver.dataId.localPoolId, storeId);
-		result = hkQueue->sendMessage(receiver.destinationQueue,
-				&notification);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-		}
-		toReset = poolObj;
-	}
-	else {
-		LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
-				receiver.dataId.sid);
-		if(dataSet == nullptr) {
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"handleNotificationSnapshot", DATASET_NOT_FOUND);
-			return DATASET_NOT_FOUND;
-		}
-
-		if(not dataSet->hasChanged()) {
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-
-		// prepare and send update snapshot.
-		timeval now;
-		Clock::getClock_timeval(&now);
-		CCSDSTime::CDS_short cds;
-		CCSDSTime::convertToCcsds(&cds, &now);
-		HousekeepingPacketUpdate updatePacket(reinterpret_cast<uint8_t*>(&cds),
-				sizeof(cds), HasLocalDpIFManagerAttorney::getDataSetHandle(owner,
-						receiver.dataId.sid));
-
-		store_address_t storeId;
-		ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		CommandMessage notification;
-		HousekeepingMessage::setUpdateSnapshotSetCommand(
-				&notification, receiver.dataId.sid, storeId);
-		result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-		if(result != HasReturnvaluesIF::RETURN_OK) {
-			status = result;
-		}
-		toReset = dataSet;
-
-	}
-	if(toReset != nullptr) {
-		handleChangeResetLogic(receiver.dataType,
-				receiver.dataId, toReset);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::addUpdateToStore(
-		HousekeepingPacketUpdate& updatePacket, store_address_t& storeId) {
-	size_t updatePacketSize = updatePacket.getSerializedSize();
-	uint8_t *storePtr = nullptr;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			updatePacket.getSerializedSize(), &storePtr);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	size_t serializedSize = 0;
-	result = updatePacket.serialize(&storePtr, &serializedSize,
-			updatePacketSize, SerializeIF::Endianness::MACHINE);
-	return result;;
-}
-
-void LocalDataPoolManager::handleChangeResetLogic(
-		DataType type, DataId dataId, MarkChangedIF* toReset) {
-	if(hkUpdateResetList == nullptr) {
-		// config error!
-		return;
-	}
-	HkUpdateResetList& listRef = *hkUpdateResetList;
-	for(auto& changeInfo: listRef) {
-		if(changeInfo.dataType != type) {
-			continue;
-		}
-		if((changeInfo.dataType == DataType::DATA_SET) and
-				(changeInfo.dataId.sid != dataId.sid)) {
-			continue;
-		}
-		if((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-				(changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-			continue;
-		}
-
-		// only one update recipient, we can reset changes status immediately.
-		if(changeInfo.updateCounter <= 1) {
-			toReset->setChanged(false);
-		}
-		// All recipients have been notified, reset the changed flag.
-		if(changeInfo.currentUpdateCounter <= 1) {
-			toReset->setChanged(false);
-			changeInfo.currentUpdateCounter = 0;
-		}
-		// Not all recipiens have been notified yet, decrement.
-		else {
-			changeInfo.currentUpdateCounter--;
-		}
-		return;
-	}
-}
-
-void LocalDataPoolManager::resetHkUpdateResetHelper() {
-	if(hkUpdateResetList == nullptr) {
-		return;
-	}
-
-	for(auto& changeInfo: *hkUpdateResetList) {
-		changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-	}
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
-		bool enableReporting, float collectionInterval, bool isDiagnostics,
-		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-	if(hkReceiverObject == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-		return QUEUE_OR_DESTINATION_INVALID;
-	}
-
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.sid = sid;
-	hkReceiver.reportingType = ReportingType::PERIODIC;
-	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
-
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet != nullptr) {
-		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
-		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
-		LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
-				owner->getPeriodicOperationFrequency(), isDiagnostics);
-	}
-
-	hkReceiversMap.push_back(hkReceiver);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t LocalDataPoolManager::subscribeForUpdatePackets(sid_t sid,
-		bool isDiagnostics, bool reportingEnabled,
-		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
-	if(hkReceiverObject == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
-		return QUEUE_OR_DESTINATION_INVALID;
-	}
-
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataId.sid = sid;
-	hkReceiver.reportingType = ReportingType::UPDATE_HK;
-	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
-
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	if(dataSet != nullptr) {
-		LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
-		LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
-	}
-
-	hkReceiversMap.push_back(hkReceiver);
-
-	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessages(
-		const uint32_t setId, object_id_t destinationObject,
-		MessageQueueId_t targetQueueId, bool generateSnapshot) {
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataType = DataType::DATA_SET;
-	hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
-	hkReceiver.destinationQueue = targetQueueId;
-	hkReceiver.objectId = destinationObject;
-	if(generateSnapshot) {
-		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-	}
-	else {
-		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-	}
-
-	hkReceiversMap.push_back(hkReceiver);
-
-	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessages(
-		const lp_id_t localPoolId, object_id_t destinationObject,
-		MessageQueueId_t targetQueueId, bool generateSnapshot) {
-	struct HkReceiver hkReceiver;
-	hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-	hkReceiver.dataId.localPoolId = localPoolId;
-	hkReceiver.destinationQueue = targetQueueId;
-	hkReceiver.objectId = destinationObject;
-	if(generateSnapshot) {
-		hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-	}
-	else {
-		hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-	}
-
-	hkReceiversMap.push_back(hkReceiver);
-
-	handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType,
-		DataId dataId) {
-	if(hkUpdateResetList == nullptr) {
-		hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-	}
-
-	for(auto& updateResetStruct: *hkUpdateResetList) {
-		if(dataType == DataType::DATA_SET) {
-			if(updateResetStruct.dataId.sid == dataId.sid) {
-				updateResetStruct.updateCounter++;
-				updateResetStruct.currentUpdateCounter++;
-				return;
-			}
-		}
-		else {
-			if(updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-				updateResetStruct.updateCounter++;
-				updateResetStruct.currentUpdateCounter++;
-				return;
-			}
-		}
-
-	}
-	HkUpdateResetHelper hkUpdateResetHelper;
-	hkUpdateResetHelper.currentUpdateCounter = 1;
-	hkUpdateResetHelper.updateCounter = 1;
-	hkUpdateResetHelper.dataType = dataType;
-	if(dataType == DataType::DATA_SET) {
-		hkUpdateResetHelper.dataId.sid = dataId.sid;
-	}
-	else {
-		hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-	}
-	hkUpdateResetList->push_back(hkUpdateResetHelper);
-}
-
-ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(
-		CommandMessage* message) {
-	Command_t command = message->getCommand();
-	sid_t sid = HousekeepingMessage::getSid(message);
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	switch(command) {
-	// Houskeeping interface handling.
-	case(HousekeepingMessage::ENABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-		result = togglePeriodicGeneration(sid, true, true);
-		break;
-	}
-
-	case(HousekeepingMessage::DISABLE_PERIODIC_DIAGNOSTICS_GENERATION): {
-		result = togglePeriodicGeneration(sid, false, true);
-		break;
-	}
-
-	case(HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-		result = togglePeriodicGeneration(sid, true, false);
-		break;
-	}
-
-	case(HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-		result = togglePeriodicGeneration(sid, false, false);
-		break;
-	}
-
-	case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): {
-		return generateSetStructurePacket(sid, true);
-	}
-
-	case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
-		return generateSetStructurePacket(sid, false);
-	}
-	case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL):
-	case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-		float newCollIntvl = 0;
-		HousekeepingMessage::getCollectionIntervalModificationCommand(message,
-				&newCollIntvl);
-		if(command == HousekeepingMessage::
-				MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL) {
-			result = changeCollectionInterval(sid, newCollIntvl, true);
-		}
-		else {
-			result = changeCollectionInterval(sid, newCollIntvl, false);
-		}
-		break;
-	}
-
-	case(HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT):
-	case(HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT): {
-		LocalPoolDataSetBase* dataSet =HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-		//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-		if(command == HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT
-				and LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
-			return WRONG_HK_PACKET_TYPE;
-		}
-		else if(command == HousekeepingMessage::GENERATE_ONE_DIAGNOSTICS_REPORT
-				and not LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
-			return WRONG_HK_PACKET_TYPE;
-		}
-		return generateHousekeepingPacket(HousekeepingMessage::getSid(message),
-				dataSet, true);
-	}
-
-	// Notification handling.
-	case(HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-		owner->handleChangedDataset(sid);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-		lp_id_t locPoolId = HousekeepingMessage::
-				getUpdateNotificationVariableCommand(message);
-		owner->handleChangedPoolVariable(locPoolId);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case(HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-		store_address_t storeId;
-		HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-		owner->handleChangedDataset(sid, storeId);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-		store_address_t storeId;
-		lp_id_t localPoolId = HousekeepingMessage::
-				getUpdateSnapshotVariableCommand(message, &storeId);
-		owner->handleChangedPoolVariable(localPoolId, storeId);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-
-	default:
-		return CommandMessageIF::UNKNOWN_COMMAND;
-	}
-
-	CommandMessage reply;
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-	}
-	else {
-		HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-	}
-	hkQueue->sendMessage(hkDestinationId, &reply);
-	return result;
-}
-
-ReturnValue_t LocalDataPoolManager::printPoolEntry(
-		lp_id_t localPoolId) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
-				localpool::POOL_ENTRY_NOT_FOUND);
-		return localpool::POOL_ENTRY_NOT_FOUND;
-	}
-	poolIter->second->print();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-MutexIF* LocalDataPoolManager::getMutexHandle() {
-	return mutex;
-}
-
-HasLocalDataPoolIF* LocalDataPoolManager::getOwner() {
-	return owner;
-}
-
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-		LocalPoolDataSetBase* dataSet, bool forDownlink,
-		MessageQueueId_t destination) {
-	if(dataSet == nullptr) {
-		// Configuration error.
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"generateHousekeepingPacket",
-				DATASET_NOT_FOUND);
-		return DATASET_NOT_FOUND;
-	}
-
-	store_address_t storeId;
-	HousekeepingPacketDownlink hkPacket(sid, dataSet);
-	size_t serializedSize = 0;
-	ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId,
-			forDownlink, &serializedSize);
-	if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) {
-		return result;
-	}
-
-	// and now we set a HK message and send it the HK packet destination.
-	CommandMessage hkMessage;
-	if(LocalPoolDataSetAttorney::isDiagnostics(*dataSet)) {
-		HousekeepingMessage::setHkDiagnosticsReply(&hkMessage, sid, storeId);
-	}
-	else {
-		HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-	}
-
-	if(hkQueue == nullptr) {
-		// error, no queue available to send packet with.
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"generateHousekeepingPacket",
-				QUEUE_OR_DESTINATION_INVALID);
-		return QUEUE_OR_DESTINATION_INVALID;
-	}
-	if(destination == MessageQueueIF::NO_QUEUE) {
-		if(hkDestinationId == MessageQueueIF::NO_QUEUE) {
-			// error, all destinations invalid
-			printWarningOrError(sif::OutputTypes::OUT_WARNING,
-					"generateHousekeepingPacket",
-					QUEUE_OR_DESTINATION_INVALID);
-		}
-		destination = hkDestinationId;
-	}
-
-	return hkQueue->sendMessage(destination, &hkMessage);
-}
-
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(
-		HousekeepingPacketDownlink& hkPacket,
-		store_address_t& storeId, bool forDownlink,
-		size_t* serializedSize) {
-	uint8_t* dataPtr = nullptr;
-	const size_t maxSize = hkPacket.getSerializedSize();
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			maxSize, &dataPtr);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-
-	if(forDownlink) {
-		return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-				SerializeIF::Endianness::BIG);
-	}
-	return hkPacket.serialize(&dataPtr, serializedSize, maxSize,
-			SerializeIF::Endianness::MACHINE);
-}
-
-void LocalDataPoolManager::setNonDiagnosticIntervalFactor(
-		uint8_t nonDiagInvlFactor) {
-	this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
-}
-
-void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-	sid_t sid = receiver.dataId.sid;
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	if(dataSet == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"performPeriodicHkGeneration",
-				DATASET_NOT_FOUND);
-		return;
-	}
-
-	if(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
-		return;
-	}
-
-	PeriodicHousekeepingHelper* periodicHelper =
-			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
-
-	if(periodicHelper == nullptr) {
-		// Configuration error.
-		return;
-	}
-
-	if(periodicHelper->checkOpNecessary()) {
-		return;
-	}
-
-	ReturnValue_t result = generateHousekeepingPacket(
-			sid, dataSet, true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		// configuration error
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalDataPoolManager::performHkOperation: "
-				<< "HK generation failed." << std::endl;
-#else
-		sif::printWarning("LocalDataPoolManager::performHkOperation: "
-				"HK generation failed.\n");
-#endif
-	}
-}
-
-
-ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid,
-		bool enable, bool isDiagnostics) {
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	if((LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and not isDiagnostics) or
-			(not LocalPoolDataSetAttorney::isDiagnostics(*dataSet) and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
-
-	if((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
-			(not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
-		return REPORTING_STATUS_UNCHANGED;
-	}
-
-	LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-		float newCollectionInterval, bool isDiagnostics) {
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
-
-	PeriodicHousekeepingHelper* periodicHelper =
-			LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
-
-	if(periodicHelper == nullptr) {
-		// config error
-		return PERIODIC_HELPER_INVALID;
-	}
-
-	periodicHelper->changeCollectionInterval(newCollectionInterval);
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid,
-		bool isDiagnostics) {
-	// Get and check dataset first.
-	//LocalPoolDataSetBase* dataSet = owner->getDataSetHandle(sid);
-	LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-	if(dataSet == nullptr) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"performPeriodicHkGeneration",
-				DATASET_NOT_FOUND);
-		return DATASET_NOT_FOUND;
-	}
-
-
-	bool targetIsDiagnostics = LocalPoolDataSetAttorney::isDiagnostics(*dataSet);
-	if((targetIsDiagnostics and not isDiagnostics) or
-			(not targetIsDiagnostics and isDiagnostics)) {
-		return WRONG_HK_PACKET_TYPE;
-	}
-
-	bool valid = dataSet->isValid();
-	bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
-	float collectionInterval = LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->
-			getCollectionIntervalInSeconds();
-
-	// Generate set packet which can be serialized.
-	HousekeepingSetPacket setPacket(sid,
-			reportingEnabled, valid, collectionInterval, dataSet);
-	size_t expectedSize = setPacket.getSerializedSize();
-	uint8_t* storePtr = nullptr;
-	store_address_t storeId;
-	ReturnValue_t result = ipcStore->getFreeElement(&storeId,
-			expectedSize,&storePtr);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		printWarningOrError(sif::OutputTypes::OUT_ERROR,
-				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
-				"Could not get free element from IPC store.");
-		return result;
-	}
-
-	// Serialize set packet into store.
-	size_t size = 0;
-	result = setPacket.serialize(&storePtr, &size, expectedSize,
-			SerializeIF::Endianness::BIG);
-	if(expectedSize != size) {
-		printWarningOrError(sif::OutputTypes::OUT_WARNING,
-				"generateSetStructurePacket", HasReturnvaluesIF::RETURN_FAILED,
-				"Expected size is not equal to serialized size");
-	}
-
-	// Send structure reporting reply.
-	CommandMessage reply;
-	if(isDiagnostics) {
-		HousekeepingMessage::setDiagnosticsStuctureReportReply(&reply,
-				sid, storeId);
-	}
-	else {
-		HousekeepingMessage::setHkStuctureReportReply(&reply,
-				sid, storeId);
-	}
-
-	hkQueue->reply(&reply);
-	return result;
-}
-
-void LocalDataPoolManager::clearReceiversList() {
-	// clear the vector completely and releases allocated memory.
-	HkReceivers().swap(hkReceiversMap);
-}
-
-MutexIF* LocalDataPoolManager::getLocalPoolMutex() {
-	return this->mutex;
-}
-
-object_id_t LocalDataPoolManager::getCreatorObjectId() const {
-	return owner->getObjectId();
-	//return owner->getObjectId();
-}
-
-void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
-		const char* functionName, ReturnValue_t error, const char* errorPrint) {
-	if(errorPrint == nullptr) {
-		if(error == DATASET_NOT_FOUND) {
-			errorPrint = "Dataset not found";
-		}
-		else if(error == POOLOBJECT_NOT_FOUND) {
-			errorPrint = "Pool Object not found";
-		}
-		else if(error == HasReturnvaluesIF::RETURN_FAILED) {
-			if(outputType == sif::OutputTypes::OUT_WARNING) {
-				errorPrint = "Generic Warning";
-			}
-			else {
-				errorPrint = "Generic error";
-			}
-		}
-		else if(error == QUEUE_OR_DESTINATION_INVALID) {
-			errorPrint = "Queue or destination not set";
-		}
-		else if(error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
-			errorPrint = "Pool entry type conflict";
-		}
-		else if(error == localpool::POOL_ENTRY_NOT_FOUND) {
-			errorPrint = "Pool entry not found";
-		}
-		else {
-			errorPrint = "Unknown error";
-		}
-	}
-
-	if(outputType == sif::OutputTypes::OUT_WARNING) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "LocalDataPoolManager::" << functionName
-				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
-				<< std::dec << std::setfill(' ') << std::endl;
-#else
-		sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				owner->getObjectId(), errorPrint);
-#endif
-	}
-	else if(outputType == sif::OutputTypes::OUT_ERROR) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "LocalDataPoolManager::" << functionName
-				<< ": Object ID " << std::setw(8) << std::setfill('0')
-				<< std::hex << owner->getObjectId() << " | " << errorPrint
-				<< std::dec << std::setfill(' ') << std::endl;
-#else
-		sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n",
-				owner->getObjectId(), errorPrint);
-#endif
-	}
-}
-
-LocalDataPoolManager* LocalDataPoolManager::getHkManagerHandle() {
-	return this;
-}

datapoollocal/LocalDataPoolManager.h

@@ -1,419 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-
-#include "ProvidesDataPoolSubscriptionIF.h"
-#include "AccessLocalPoolF.h"
-
-#include "../serviceinterface/ServiceInterface.h"
-#include "../housekeeping/HousekeepingPacketDownlink.h"
-#include "../housekeeping/HousekeepingMessage.h"
-#include "../housekeeping/PeriodicHousekeepingHelper.h"
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../objectmanager/SystemObjectIF.h"
-#include "../ipc/MutexIF.h"
-#include "../ipc/CommandMessage.h"
-#include "../ipc/MessageQueueIF.h"
-#include "../ipc/MutexHelper.h"
-
-#include <map>
-#include <vector>
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class LocalPoolDataSetBase;
-class HousekeepingPacketUpdate;
-class HasLocalDataPoolIF;
-class LocalDataPool;
-
-/**
- * @brief 		This class is the managing instance for the local data pool.
- * @details
- * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this manager class as a member and implement
- * the HasLocalDataPoolIF.
- *
- * The manager offers some adaption points and functions which can be used
- * by the owning class to simplify data handling significantly.
- *
- * Please ensure that both initialize and initializeAfterTaskCreation are
- * called at some point by the owning class in the respective functions of the
- * same name!
- *
- * Users of the data pool use the helper classes LocalDataSet,
- * LocalPoolVariable and LocalPoolVector to access pool entries in
- * a thread-safe and efficient way.
- *
- * The local data pools employ a blackboard logic: Only the most recent
- * value is stored. The helper classes offer a read() and commit() interface
- * through the PoolVariableIF which is used to read and update values.
- * Each pool entry has a valid state too.
- * @author 		R. Mueller
- */
-class LocalDataPoolManager: public ProvidesDataPoolSubscriptionIF,
-		public AccessPoolManagerIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
-	//! Some classes using the pool manager directly need to access class internals of the
-	//! manager. The attorney provides granular control of access to these internals.
-	friend class LocalDpManagerAttorney;
-public:
-	static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
-
-    static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
-
-    static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
-    static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
-    static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
-    static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
-    static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
-
-
-    /**
-     * This constructor is used by a class which wants to implement
-     * a personal local data pool. The queueToUse can be supplied if it
-     * is already known.
-     *
-     * initialize() has to be called in any case before using the object!
-     * @param owner
-     * @param queueToUse
-     * @param appendValidityBuffer Specify whether a buffer containing the
-     * validity state is generated  when serializing or deserializing packets.
-     */
-	LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-	        bool appendValidityBuffer = true);
-	virtual~ LocalDataPoolManager();
-
-	/**
-	 * Assigns the queue to use. Make sure to call this in the #initialize
-	 * function of the owner.
-	 * @param queueToUse
-	 * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
-	 * @return
-	 */
-	ReturnValue_t initialize(MessageQueueIF* queueToUse);
-
-	/**
-	 * Initializes the map by calling the map initialization function and
-	 * setting the periodic factor for non-diagnostic packets.
-	 * Don't forget to call this in the #initializeAfterTaskCreation call of
-	 * the owner, otherwise the map will be invalid!
-	 * @param nonDiagInvlFactor
-	 * @return
-	 */
-	ReturnValue_t initializeAfterTaskCreation(
-	        uint8_t nonDiagInvlFactor = 5);
-
-    /**
-     * @brief   This should be called in the periodic handler of the owner.
-     * @details
-     * This in generally called in the #performOperation function of the owner.
-     * It performs all the periodic functionalities of the data pool manager,
-     * for example generating periodic HK packets.
-     * Marked virtual as an adaption point for custom data pool managers.
-     * @return
-     */
-    virtual ReturnValue_t performHkOperation();
-
-	/**
-	 * @brief   Subscribe for the generation of periodic packets.
-	 * @details
-     * This subscription mechanism will generally be used by the data creator
-     * to generate housekeeping packets which are downlinked directly.
-	 * @return
-	 */
-	ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
-			float collectionInterval, bool isDiagnostics,
-			object_id_t packetDestination = defaultHkDestination) override;
-
-	/**
-	 * @brief   Subscribe for the  generation of packets if the dataset
-	 *          is marked as changed.
-	 * @details
-	 * This subscription mechanism will generally be used by the data creator.
-	 * @param sid
-	 * @param isDiagnostics
-	 * @param packetDestination
-	 * @return
-	 */
-    ReturnValue_t subscribeForUpdatePackets(sid_t sid, bool reportingEnabled,
-            bool isDiagnostics,
-            object_id_t packetDestination = defaultHkDestination) override;
-
-	/**
-	 * @brief   Subscribe for a notification message which will be sent
-	 *          if a dataset has changed.
-	 * @details
-	 * This subscription mechanism will generally be used internally by
-	 * other software components.
-	 * @param setId     Set ID of the set to receive update messages from.
-	 * @param destinationObject
-	 * @param targetQueueId
-	 * @param generateSnapshot If this is set to true, a copy of the current
-	 * data with a timestamp will be generated and sent via message.
-	 * Otherwise, only an notification message is sent.
-	 * @return
-	 */
-	ReturnValue_t subscribeForSetUpdateMessages(const uint32_t setId,
-	        object_id_t destinationObject,
-	        MessageQueueId_t targetQueueId,
-	        bool generateSnapshot) override;
-
-    /**
-     * @brief   Subscribe for an notification message which will be sent if a
-     *          pool variable has changed.
-     * @details
-     * This subscription mechanism will generally be used internally by
-     * other software components.
-     * @param localPoolId Pool ID of the pool variable
-     * @param destinationObject
-     * @param targetQueueId
-     * @param generateSnapshot If this is set to true, a copy of the current
-     * data with a timestamp will be generated and sent via message.
-     * Otherwise, only an notification message is sent.
-     * @return
-     */
-    ReturnValue_t subscribeForVariableUpdateMessages(const lp_id_t localPoolId,
-            object_id_t destinationObject,
-            MessageQueueId_t targetQueueId,
-            bool generateSnapshot) override;
-
-    MutexIF* getLocalPoolMutex() override;
-
-	/**
-	 * Non-Diagnostics packets usually have a lower minimum sampling frequency
-	 * than diagnostic packets.
-	 * A factor can be specified to determine the minimum sampling frequency
-	 * for non-diagnostic packets. The minimum sampling frequency of the
-	 * diagnostics packets,which is usually jusst the period of the
-	 * performOperation calls, is multiplied with that factor.
-	 * @param factor
-	 */
-	void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
-
-    /**
-     * @brief   The manager is also able to handle housekeeping messages.
-     * @details
-     * This most commonly is used to handle messages for the housekeeping
-     * interface, but the manager is also able to handle update notifications
-     * and calls a special function which can be overriden by a child class
-     * to handle data set or pool variable updates. This is relevant
-     * for classes like controllers which have their own local datapool
-     * but pull their data from other local datapools.
-     * @param message
-     * @return
-     */
-    virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-	/**
-	 * Generate a housekeeping packet with a given SID.
-	 * @param sid
-	 * @return
-	 */
-	ReturnValue_t generateHousekeepingPacket(sid_t sid,
-			LocalPoolDataSetBase* dataSet, bool forDownlink,
-			MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-
-	HasLocalDataPoolIF* getOwner();
-
-	ReturnValue_t printPoolEntry(lp_id_t localPoolId);
-
-    /**
-     * Different types of housekeeping reporting are possible.
-     *  1. PERIODIC:
-     *     HK packets are generated in fixed intervals and sent to
-     *     destination. Fromat will be raw.
-     *  2. UPDATE_NOTIFICATION:
-     *     Notification will be sent out if HK data has changed.
-     *  3. UPDATE_SNAPSHOT:
-     *     HK packets are only generated if explicitely requested.
-     *     Propably not necessary, just use multiple local data sets or
-     *     shared datasets.
-     */
-    enum class ReportingType: uint8_t {
-        //! Periodic generation of HK packets.
-        PERIODIC,
-        //! Housekeeping packet will be generated if values have changed.
-        UPDATE_HK,
-		//! Update notification will be sent out as message.
-		UPDATE_NOTIFICATION,
-        //! Notification will be sent out as message and a snapshot of the
-        //! current data will be generated.
-        UPDATE_SNAPSHOT,
-    };
-
-    /**
-     * Different data types are possible in the HK receiver map.
-     * For example, updates can be requested for full datasets or
-     * for single pool variables. Periodic reporting is only possible for
-     * data sets.
-     */
-    enum class DataType: uint8_t {
-    	LOCAL_POOL_VARIABLE,
-		DATA_SET
-    };
-
-    /* Copying forbidden */
-    LocalDataPoolManager(const LocalDataPoolManager &) = delete;
-    LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-    /**
-     * This function can be used to clear the receivers list. This is
-     * intended for test functions and not for regular operations, because
-     * the insertion operations allocate dynamically.
-     */
-    void clearReceiversList();
-
-    object_id_t getCreatorObjectId() const;
-
-    virtual LocalDataPoolManager* getHkManagerHandle() override;
-private:
-    localpool::DataPool localPoolMap;
-    //! Every housekeeping data manager has a mutex to protect access
-    //! to it's data pool.
-    MutexIF* mutex = nullptr;
-
-    /** The class which actually owns the manager (and its datapool). */
-    HasLocalDataPoolIF* owner = nullptr;
-
-    uint8_t nonDiagnosticIntervalFactor = 0;
-
-	/** Default receiver for periodic HK packets */
-	static object_id_t defaultHkDestination;
-	MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
-
-    union DataId {
-        DataId(): sid() {};
-        sid_t sid;
-        lp_id_t localPoolId;
-    };
-
-    /** The data pool manager will keep an internal map of HK receivers. */
-    struct HkReceiver {
-		/** Object ID of receiver */
-		object_id_t objectId = objects::NO_OBJECT;
-
-		DataType dataType = DataType::DATA_SET;
-        DataId dataId;
-
-        ReportingType reportingType = ReportingType::PERIODIC;
-        MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-    };
-
-    /** This vector will contain the list of HK receivers. */
-    using HkReceivers = std::vector<struct HkReceiver>;
-
-    HkReceivers hkReceiversMap;
-
-    struct HkUpdateResetHelper {
-        DataType dataType = DataType::DATA_SET;
-        DataId dataId;
-        uint8_t updateCounter;
-        uint8_t currentUpdateCounter;
-    };
-
-    using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
-    // Will only be created when needed.
-    HkUpdateResetList* hkUpdateResetList = nullptr;
-
-    /** This is the map holding the actual data. Should only be initialized
-     * once ! */
-    bool mapInitialized = false;
-    /** This specifies whether a validity buffer is appended at the end
-     * of generated housekeeping packets. */
-    bool appendValidityBuffer = true;
-
-	/**
-	 * @brief Queue used for communication, for example commands.
-	 * Is also used to send messages. Can be set either in the constructor
-     * or in the initialize() function.
-	 */
-	MessageQueueIF* hkQueue = nullptr;
-
-	/** Global IPC store is used to store all packets. */
-	StorageManagerIF* ipcStore = nullptr;
-	/**
-	 * Get the pointer to the mutex. Can be used to lock the data pool
-	 * externally. Use with care and don't forget to unlock locked mutexes!
-	 * For now, only friend classes can accss this function.
-	 * @return
-	 */
-	MutexIF* getMutexHandle();
-
-	/**
-	 * Read a variable by supplying its local pool ID and assign the pool
-	 * entry to the supplied PoolEntry pointer. The type of the pool entry
-	 * is deduced automatically. This call is not thread-safe!
-	 * For now, only friend classes like LocalPoolVar may access this
-	 * function.
-	 * @tparam T Type of the pool entry
-	 * @param localPoolId Pool ID of the variable to read
-	 * @param poolVar [out] Corresponding pool entry will be assigned to the
-	 * 						supplied pointer.
-	 * @return
-	 */
-	template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
-			PoolEntry<T> **poolEntry);
-
-    /**
-     * This function is used to fill the local data pool map with pool
-     * entries. It should only be called once by the pool owner.
-     * @param localDataPoolMap
-     * @return
-     */
-    ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
-	ReturnValue_t serializeHkPacketIntoStore(
-	        HousekeepingPacketDownlink& hkPacket,
-	        store_address_t& storeId, bool forDownlink, size_t* serializedSize);
-
-	void performPeriodicHkGeneration(HkReceiver& hkReceiver);
-	ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable,
-			bool isDiagnostics);
-	ReturnValue_t changeCollectionInterval(sid_t sid,
-			float newCollectionInterval, bool isDiagnostics);
-	ReturnValue_t generateSetStructurePacket(sid_t sid, bool isDiagnostics);
-
-	void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
-	void handleChangeResetLogic(DataType type,
-	        DataId dataId, MarkChangedIF* toReset);
-	void resetHkUpdateResetHelper();
-
-	ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver,
-            ReturnValue_t& status);
-	ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver,
-	        ReturnValue_t& status);
-	ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver,
-            ReturnValue_t& status);
-	ReturnValue_t addUpdateToStore(HousekeepingPacketUpdate& updatePacket,
-	        store_address_t& storeId);
-
-	void printWarningOrError(sif::OutputTypes outputType,
-			const char* functionName,
-			ReturnValue_t errorCode = HasReturnvaluesIF::RETURN_FAILED,
-			const char* errorPrint = nullptr);
-};
-
-
-template<class T> inline
-ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-		PoolEntry<T> **poolEntry) {
-	auto poolIter = localPoolMap.find(localPoolId);
-	if (poolIter == localPoolMap.end()) {
-    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			localpool::POOL_ENTRY_NOT_FOUND);
-		return localpool::POOL_ENTRY_NOT_FOUND;
-	}
-
-	*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
-	if(*poolEntry == nullptr) {
-    	printWarningOrError(sif::OutputTypes::OUT_ERROR, "fetchPoolEntry",
-    			localpool::POOL_ENTRY_TYPE_CONFLICT);
-		return localpool::POOL_ENTRY_TYPE_CONFLICT;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */

datapoollocal/SharedLocalDataSet.cpp

@@ -1,16 +0,0 @@
-#include "SharedLocalDataSet.h"
-
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid,
-        const size_t maxSize): SystemObject(objectId),
-        LocalPoolDataSetBase(sid, nullptr, maxSize) {
-    this->setContainer(poolVarVector.data());
-    datasetLock = MutexFactory::instance()->createMutex();
-}
-
-ReturnValue_t SharedLocalDataSet::lockDataset(dur_millis_t mutexTimeout) {
-    return datasetLock->lockMutex(MutexIF::TimeoutType::WAITING, mutexTimeout);
-}
-
-ReturnValue_t SharedLocalDataSet::unlockDataset() {
-    return datasetLock->unlockMutex();
-}

defaultcfg/fsfwconfig/CMakeLists.txt

@@ -1,15 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE
-	ipc/missionMessageTypes.cpp
-	objects/FsfwFactory.cpp
-	pollingsequence/PollingSequenceFactory.cpp
-)
-
-# Should be added to include path
-target_include_directories(${TARGET_NAME} PRIVATE
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-if(NOT FSFW_CONFIG_PATH)
-	set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR})
-endif()
-

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

doc/README-config.md

@@ -1,12 +1,30 @@
-
-## Configuring the FSFW
+Configuring the FSFW
+======
 
 The FSFW can be configured via the `fsfwconfig` folder. A template folder has
 been provided to have a starting point for this. The folder should be added
-to the include path.
+to the include path. The primary configuration file is the `FSFWConfig.h` folder. Some
+of the available options will be explained in more detail here.
 
+# Auto-Translation of Events
 
-### Configuring the Event Manager
+The FSFW allows the automatic translation of events, which allows developers to track triggered
+events directly via console output. Using this feature requires:
+
+1. `FSFW_OBJ_EVENT_TRANSLATION` set to 1 in the configuration file.
+2. Special auto-generated translation files which translate event IDs and object IDs into
+   human readable strings. These files can be generated using the 
+   [modgen Python scripts](https://git.ksat-stuttgart.de/source/modgen.git).
+3. The generated translation files for the object IDs should be named `translatesObjects.cpp`
+   and `translateObjects.h` and should be copied to the `fsfwconfig/objects` folder
+4. The generated translation files for the event IDs should be named `translateEvents.cpp` and
+   `translateEvents.h` and should be copied to the `fsfwconfig/events` folder
+   
+An example implementations of these translation file generators can be found as part
+of the [SOURCE project here](https://git.ksat-stuttgart.de/source/sourceobsw/-/tree/development/generators)
+or the [FSFW example](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example_public/src/branch/master/generators)
+
+## Configuring the Event Manager
 
 The number of allowed subscriptions can be modified with the following
 parameters:
@@ -19,3 +37,4 @@ static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
 static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 }
 ```
+

doc/README-core.md

@@ -19,8 +19,9 @@ A nullptr check of the returning Pointer must be done. This function is based on
 ```cpp
 template <typename T> T* ObjectManagerIF::get( object_id_t id )
 ```
-* A typical way to create all objects on startup is a handing a static produce function to the ObjectManager on creation.
-By calling objectManager->initialize() the produce function will be called and all SystemObjects will be initialized afterwards.
+* A typical way to create all objects on startup is a handing a static produce function to the
+  ObjectManager on creation. By calling objectManager->initialize() the produce function will be
+  called and all SystemObjects will be initialized afterwards.
 
 ### Event Manager
 
@@ -36,14 +37,19 @@ By calling objectManager->initialize() the produce function will be called and a
 
 ### Stores
 
-* The message based communication can only exchange a few bytes of information inside the message itself. Therefore, additional information can 
-  be exchanged with Stores. With this, only the store address must be exchanged in the message.
-* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC Store is used. For outgoing TM a TM store is used.
+* The message based communication can only exchange a few bytes of information inside the message
+  itself. Therefore, additional information can  be exchanged with Stores. With this, only the
+  store address must be exchanged in the message.
+* Internally, the FSFW uses an IPC Store to exchange data between processes. For incoming TCs a TC
+  Store is used. For outgoing TM a TM store is used.
 * All of them should use the Thread Safe Class storagemanager/PoolManager
 
 ### Tasks
 
 There are two different types of tasks:
- * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the insertion to the Tasks.
- * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for DeviceHandlers, where polling should be in a defined order. An example can be found in defaultcfg/fsfwconfig/pollingSequence
+ * The PeriodicTask just executes objects that are of type ExecutableObjectIF in the order of the
+   insertion to the Tasks.
+ * FixedTimeslotTask executes a list of calls in the order of the given list. This is intended for
+   DeviceHandlers, where polling should be in a defined order. An example can be found in 
+   `defaultcfg/fsfwconfig/pollingSequence` folder
 

doc/README-highlevel.md

@@ -1,99 +1,135 @@
-# High-level overview
+High-level overview
+======
 
-## Structure
+# Structure
 
 The general structure is driven by the usage of interfaces provided by objects. 
-The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be widely available, even with older compilers.
+The FSFW uses C++11 as baseline. The intention behind this is that this C++ Standard should be
+widely available, even with older compilers.
 The FSFW uses dynamic allocation during the initialization but provides static containers during runtime. 
 This simplifies the instantiation of objects and allows the usage of some standard containers. 
-Dynamic Allocation after initialization is discouraged and different solutions are provided in the FSFW to achieve that.
-The fsfw uses run-time type information but exceptions are not allowed.
+Dynamic Allocation after initialization is discouraged and different solutions are provided in the
+FSFW to achieve that. The fsfw uses run-time type information but exceptions are not allowed.
 
-### Failure Handling
+# Failure Handling
 
-Functions should return a defined ReturnValue_t to signal to the caller that something has gone wrong. 
-Returnvalues must be unique. For this the function HasReturnvaluesIF::makeReturnCode or the Macro MAKE_RETURN can be used.
-The CLASS_ID is a unique id for that type of object. See returnvalues/FwClassIds.
+Functions should return a defined `ReturnValue_t` to signal to the caller that something has
+gone wrong. Returnvalues must be unique. For this the function `HasReturnvaluesIF::makeReturnCode`
+or the macro `MAKE_RETURN` can be used. The `CLASS_ID` is a unique id for that type of object.
+See `returnvalues/FwClassIds` folder. The user can add custom `CLASS_ID`s via the
+`fsfwconfig` folder.
 
-### OSAL
+# OSAL
 
 The FSFW provides operation system abstraction layers for Linux, FreeRTOS and RTEMS. 
 The OSAL provides periodic tasks, message queues, clocks and semaphores as well as mutexes.
-The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components and how to use them.
+The [OSAL README](doc/README-osal.md#top) provides more detailed information on provided components
+and how to use them.
 
-### Core Components 
+# Core Components 
 
 The FSFW has following core components. More detailed informations can be found in the
 [core component section](doc/README-core.md#top):
 
-1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks with fixed timeslots
-2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID to the object handles.
-3. Static Stores: Different stores are provided to store data of variable size (like telecommands or small telemetry) in a pool structure without
-   using dynamic memory allocation. These pools are allocated up front.
+1. Tasks: Abstraction for different (periodic) task types like periodic tasks or tasks 
+   with fixed timeslots
+2. ObjectManager: This module stores all `SystemObjects` by mapping a provided unique object ID
+   to the object handles.
+3. Static Stores: Different stores are provided to store data of variable size (like telecommands 
+   or small telemetry) in a pool structure without using dynamic memory allocation.
+   These pools are allocated up front.
 3. Clock: This module provided common time related functions
 4. EventManager: This module allows routing of events generated by `SystemObjects`
 5. HealthTable: A component which stores the health states of objects
 
-### Static IDs in the framework
+# Static IDs in the framework
 
 Some parts of the framework use a static routing address for communication. 
-An example setup of ids can be found in the example config in "defaultcft/fsfwconfig/objects/Factory::setStaticFrameworkObjectIds()".
+An example setup of ids can be found in the example config in `defaultcft/fsfwconfig/objects`
+ inside the function `Factory::setStaticFrameworkObjectIds()`.
 
-### Events
+# Events
 
-Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. This works analog to the returnvalues.
-Every object that needs own EventIds has to get a unique SUBSYSTEM_ID. 
-Every SystemObject can call triggerEvent from the parent class.
-Therefore, event messages contain the specific EventId and the objectId of the object that has triggered.
+Events are tied to objects. EventIds can be generated by calling the Macro MAKE_EVENT. 
+This works analog to the returnvalues. Every object that needs own EventIds has to get a
+unique SUBSYSTEM_ID. Every SystemObject can call triggerEvent from the parent class.
+Therefore, event messages contain the specific EventId and the objectId of the object that
+has triggered.
 
-### Internal Communication
+# Internal Communication
 
-Components communicate mostly over Message through Queues. 
-Those queues are created by calling the singleton QueueFactory::instance()->create(). 
+Components communicate mostly via Messages through Queues. 
+Those queues are created by calling the singleton `QueueFactory::instance()->create()` which
+will create `MessageQueue` instances for the used OSAL.
 
-### External Communication
+# External Communication
 
 The external communication with the mission control system is mostly up to the user implementation.
 The FSFW provides PUS Services which can be used to but don't need to be used. 
 The services can be seen as a conversion from a TC to a message based communication and back.
 
-#### CCSDS Frames, CCSDS Space Packets and PUS
+## TMTC Communication
 
-If the communication is based on CCSDS Frames and Space Packets, several classes can be used to distributed the packets to the corresponding services. Those can be found in tcdistribution. 
-If Space Packets are used, a timestamper must be created. 
-An example can be found in the timemanager folder, this uses CCSDSTime::CDS_short.
+The FSFW provides some components to facilitate TMTC handling via the PUS commands.
+For example, a UDP or TCP PUS server socket can be opened on a specific port using the
+files located in `osal/common`. The FSFW example uses this functionality to allow sending telecommands
+and receiving telemetry using the [TMTC commander application](https://github.com/spacefisch/tmtccmd).
+Simple commands like the PUS Service 17 ping service can be tested by simply running the
+`tmtc_client_cli.py` or `tmtc_client_gui.py` utility in 
+the [example tmtc folder](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_example_public/src/branch/master/tmtc)
+while the `fsfw_example` application is running.
 
-#### Device Handlers
+More generally, any class responsible for handling incoming telecommands and sending telemetry
+can implement the generic `TmTcBridge` class located in `tmtcservices`. Many applications
+also use a dedicated polling task for reading telecommands which passes telecommands
+to the `TmTcBridge` implementation.
+
+## CCSDS Frames, CCSDS Space Packets and PUS
+
+If the communication is based on CCSDS Frames and Space Packets, several classes can be used to
+distributed the packets to the corresponding services. Those can be found in `tcdistribution`. 
+If Space Packets are used, a timestamper has to be provided by the user. 
+An example can be found in the `timemanager` folder, which uses `CCSDSTime::CDS_short`.
+
+# Device Handlers
 
 DeviceHandlers are another important component of the FSFW. 
-The idea is, to have a software counterpart of every physical device to provide a simple mode, health and commanding interface.
-By separating the underlying Communication Interface with DeviceCommunicationIF, a device handler (DH) can be tested on different hardware.
-The DH has mechanisms to monitor the communication with the physical device which allow for FDIR reaction. 
-Device Handlers can be created by overriding `DeviceHandlerBase`. 
-A standard FDIR component for the DH will be created automatically but can be overwritten by the user.
-More information on DeviceHandlers can be found in the related [documentation section](doc/README-devicehandlers.md#top).
+The idea is, to have a software counterpart of every physical device to provide a simple mode,
+health and commanding interface. By separating the underlying Communication Interface with 
+`DeviceCommunicationIF`, a device handler (DH) can be tested on different hardware.
+The DH has mechanisms to monitor the communication with the physical device which allow
+for FDIR reaction.  Device Handlers can be created by implementing `DeviceHandlerBase`. 
+A standard FDIR component for the DH will be created automatically but can
+be overwritten by the user. More information on DeviceHandlers can be found in the
+related [documentation section](doc/README-devicehandlers.md#top).
 
-#### Modes, Health
+# Modes and Health
 
-The two interfaces HasModesIF and HasHealthIF provide access for commanding and monitoring of components.
-On-board Mode Management is implement in hierarchy system. 
+The two interfaces `HasModesIF` and `HasHealthIF` provide access for commanding and monitoring
+of components. On-board Mode Management is implement in hierarchy system. 
 DeviceHandlers and Controllers are the lowest part of the hierarchy. 
-The next layer are Assemblies. Those assemblies act as a component which handle redundancies of handlers. 
-Assemblies share a common core with the next level which are the Subsystems. 
+The next layer are Assemblies. Those assemblies act as a component which handle
+redundancies of handlers. Assemblies share a common core with the next level which
+are the Subsystems. 
 
-Those Assemblies are intended to act as auto-generated components from a database which describes the subsystem modes. 
-The definitions contain transition and target tables which contain the DH, Assembly and Controller Modes to be commanded.
-Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a switch into any higher AOCS mode might first turn on the sensors, than the actuators and the controller as last component. 
+Those Assemblies are intended to act as auto-generated components from a database which describes
+the subsystem modes. The definitions contain transition and target tables which contain the DH,
+Assembly and Controller Modes to be commanded.
+Transition tables contain as many steps as needed to reach the mode from any other mode, e.g. a
+switch into any higher AOCS mode might first turn on the sensors, than the actuators and the
+controller as last component. 
 The target table is used to describe the state that is checked continuously by the subsystem. 
 All of this allows System Modes to be generated as Subsystem object as well from the same database. 
 This System contains list of subsystem modes in the transition and target tables. 
-Therefore, it allows a modular system to create system modes and easy commanding of those, because only the highest components must be commanded.
+Therefore, it allows a modular system to create system modes and easy commanding of those, because
+only the highest components must be commanded.
 
 The health state represents if the component is able to perform its tasks. 
 This can be used to signal the system to avoid using this component instead of a redundant one.
 The on-board FDIR uses the health state for isolation and recovery. 
 
-## Unit Tests
+# Unit Tests
 
-Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include catch2 itself. More information on how to run these tests can be found in the separate
+Unit Tests are provided in the unittest folder. Those use the catch2 framework but do not include
+catch2 itself. More information on how to run these tests can be found in the separate
 [`fsfw_tests` reposoitory](https://egit.irs.uni-stuttgart.de/fsfw/fsfw_tests)

doc/README-localpools.md

@@ -1,3 +1,172 @@
-## Local Data Pools
+## Local Data Pools Developer Information
+
+The following text is targeted towards mission software developers which would like
+to use the local data pools provided by the FSFW to store data like sensor values so they can be 
+used by other software objects like controllers as well. If a custom class should have a local 
+pool which  can be used by other software objects as well, following steps have to be performed:
+
+1. Create a `LocalDataPoolManager` member object in the custom class
+2. Implement the `HasLocalDataPoolIF` with specifies the interface between the local pool manager
+and the class owning the local pool.
+
+The local data pool manager is also able to process housekeeping service requests in form
+of messages, generate periodic housekeeping packet, generate notification and snapshots of changed
+variables and datasets and process notifications and snapshots coming from other objects.
+The two former tasks are related to the external interface using telemetry and telecommands (TMTC)
+while the later two are related to data consumers like controllers only acting on data change 
+detected by the data creator instead of checking the data manually each cycle. Two important 
+framework classes `DeviceHandlerBase` and `ExtendedControllerBase` already perform the two steps 
+shown above so the steps required are altered slightly.
+
+### Storing and Accessing pool data 
+
+The pool manager is responsible for thread-safe access of the pool data, but the actual
+access to the pool data from the point of view of a mission software developer happens via proxy
+classes like pool variable classes. These classes store a copy
+of the pool variable with the matching datatype and copy the actual data from the local pool
+on a `read` call. Changed variables can then be written to the local pool with a `commit` call.
+The `read` and `commit` calls are thread-safe and can be called concurrently from data creators
+and data consumers. Generally, a user will create a dataset class which in turn groups all 
+cohesive pool variables. These sets simply iterator over the list of variables and call the 
+`read` and `commit` functions of each variable. The following diagram shows the
+high-level architecture of the local data pools.
+
+<img align="center" src="./images/PoolArchitecture.png" width="50%"> <br>
+
+An example is shown for using the local data pools with a Gyroscope.
+For example, the following code shows an implementation to access data from a Gyroscope taken
+from the SOURCE CubeSat project:
+
+```cpp
+class GyroPrimaryDataset: public StaticLocalDataSet<3 * sizeof(float)> {
+public:
+    /**
+     * Constructor for data users
+     * @param gyroId
+     */
+    GyroPrimaryDataset(object_id_t gyroId):
+            StaticLocalDataSet(sid_t(gyroId, gyrodefs::GYRO_DATA_SET_ID)) {
+        setAllVariablesReadOnly();
+    }
+
+    lp_var_t<float> angVelocityX = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_X, this);
+    lp_var_t<float> angVelocityY = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_Y, this);
+    lp_var_t<float> angVelocityZ = lp_var_t<float>(sid.objectId,
+            gyrodefs::ANGULAR_VELOCITY_Z, this);
+private:
+
+    friend class GyroHandler;
+    /**
+     * Constructor for data creator
+     * @param hkOwner
+     */
+    GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner):
+            StaticLocalDataSet(hkOwner, gyrodefs::GYRO_DATA_SET_ID) {}
+};
+```
+
+There is a public constructor for users which sets all variables to read-only and there is a
+constructor for the GyroHandler data creator by marking it private and declaring the `GyroHandler`
+as a friend class. Both the atittude controller and the `GyroHandler` can now
+use the same class definition to access the pool variables with `read` and `commit` semantics
+in a thread-safe way. Generally, each class requiring access will have the set class as a member
+class. The data creator will also be generally a `DeviceHandlerBase` subclass and some additional
+steps are necessary to expose the set for housekeeping purposes.
+
+### Using the local data pools in a `DeviceHandlerBase` subclass
+
+It is very common to store data generated by devices like a sensor into a pool which can 
+then be used by other objects. Therefore, the `DeviceHandlerBase` already has a
+local pool. Using the aforementioned example, our `GyroHandler` will now have the set class
+as a member:
+
+```cpp
+class GyroHandler: ... {
+
+public:
+	...
+private:
+	...
+	GyroPrimaryDataset gyroData;
+	...
+};
+```
+
+The constructor used for the creators expects the owner class as a parameter, so we initialize
+the object in the `GyroHandler` constructor like this:
+
+```cpp
+GyroHandler::GyroHandler(object_id_t objectId, object_id_t comIF,
+        CookieIF *comCookie, uint8_t switchId):
+        DeviceHandlerBase(objectId, comIF, comCookie), switchId(switchId),
+		gyroData(this) {}
+```
+
+We need to assign the set to a reply ID used in the `DeviceHandlerBase`. 
+The combination of the `GyroHandler` object ID and the reply ID will be the 64-bit structure ID
+`sid_t` and is used to globally identify the set, for example when requesting housekeeping data or
+generating update messages. We need to assign our custom set class in some way so that the local 
+pool manager can access the custom data sets as well.
+By default, the `getDataSetHandle` will take care of this tasks. The default implementation for a
+`DeviceHandlerBase` subclass will use the internal command map to retrieve 
+a handle to a dataset from a given reply ID. Therefore,
+we assign the set in the `fillCommandAndReplyMap` function:
+
+```cpp
+void GyroHandler::fillCommandAndReplyMap() {
+	...
+	this->insertInCommandAndReplyMap(gyrodefs::GYRO_DATA, 3, &gyroData);
+	...
+}
+```
+
+Now, we need to create the actual pool entries as well, using the `initializeLocalDataPool` 
+function. Here, we also immediately subscribe for periodic housekeeping packets 
+with an interval of 4 seconds. They are still disabled in this example and can be enabled 
+with a housekeeping service command.
+
+```cpp
+ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+		LocalDataPoolManager &poolManager) {
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_X,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Y,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::ANGULAR_VELOCITY_Z,
+			new PoolEntry<float>({0.0}));
+	localDataPoolMap.emplace(gyrodefs::GENERAL_CONFIG_REG42,
+			new PoolEntry<uint8_t>({0}));
+	localDataPoolMap.emplace(gyrodefs::RANGE_CONFIG_REG43,
+			new PoolEntry<uint8_t>({0}));
+
+	poolManager.subscribeForPeriodicPacket(gyroData.getSid(), false, 4.0, false);
+	return HasReturnvaluesIF::RETURN_OK;
+}
+```
+
+Now, if we receive some sensor data and converted them into the right format, 
+we can write it into the pool like this, using a guard class to ensure the set is commited back 
+in any case:
+
+```cpp
+PoolReadGuard readHelper(&gyroData);
+if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+	if(not gyroData.isValid()) {
+		gyroData.setValidity(true, true);
+	}
+
+	gyroData.angVelocityX = angularVelocityX;
+	gyroData.angVelocityY = angularVelocityY;
+	gyroData.angVelocityZ = angularVelocityZ;
+}
+```
+
+The guard class will commit the changed data on destruction automatically.
+
+### Using the local data pools in a `ExtendedControllerBase` subclass
+
+Coming soon
 
 

doc/doxy/.gitignore

@@ -0,0 +1,3 @@
+html
+latex
+rtf

events/CMakeLists.txt

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

events/EventManager.cpp

@@ -1,176 +0,0 @@
-#include "EventManager.h"
-#include "EventMessage.h"
-
-#include <FSFWConfig.h>
-#include "../serviceinterface/ServiceInterfaceStream.h"
-#include "../ipc/QueueFactory.h"
-#include "../ipc/MutexFactory.h"
-
-
-// If one checks registerListener calls, there are around 40 (to max 50)
-// objects registering for certain events.
-// Each listener requires 1 or 2 EventIdMatcher and 1 or 2 ReportRangeMatcher.
-// So a good guess is 75 to a max of 100 pools required for each, which fits well.
-const LocalPool::LocalPoolConfig EventManager::poolConfig = {
-        {fsfwconfig::FSFW_EVENTMGMR_MATCHTREE_NODES,
-        		sizeof(EventMatchTree::Node)},
-        {fsfwconfig::FSFW_EVENTMGMT_EVENTIDMATCHERS,
-        		sizeof(EventIdRangeMatcher)},
-        {fsfwconfig::FSFW_EVENTMGMR_RANGEMATCHERS,
-        		sizeof(ReporterRangeMatcher)}
-};
-
-EventManager::EventManager(object_id_t setObjectId) :
-		SystemObject(setObjectId),
-		factoryBackend(0, poolConfig, false, true) {
-	mutex = MutexFactory::instance()->createMutex();
-	eventReportQueue = QueueFactory::instance()->createMessageQueue(
-			MAX_EVENTS_PER_CYCLE, EventMessage::EVENT_MESSAGE_SIZE);
-}
-
-EventManager::~EventManager() {
-	QueueFactory::instance()->deleteMessageQueue(eventReportQueue);
-	MutexFactory::instance()->deleteMutex(mutex);
-}
-
-MessageQueueId_t EventManager::getEventReportQueue() {
-	return eventReportQueue->getId();
-}
-
-ReturnValue_t EventManager::performOperation(uint8_t opCode) {
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	while (result == HasReturnvaluesIF::RETURN_OK) {
-		EventMessage message;
-		result = eventReportQueue->receiveMessage(&message);
-		if (result == HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_OBJ_EVENT_TRANSLATION == 1
-			printEvent(&message);
-#endif
-			notifyListeners(&message);
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-void EventManager::notifyListeners(EventMessage* message) {
-	lockMutex();
-	for (auto iter = listenerList.begin(); iter != listenerList.end(); ++iter) {
-		if (iter->second.match(message)) {
-			MessageQueueSenderIF::sendMessage(iter->first, message,
-					message->getSender());
-		}
-	}
-	unlockMutex();
-}
-
-ReturnValue_t EventManager::registerListener(MessageQueueId_t listener,
-bool forwardAllButSelected) {
-	auto result = listenerList.insert(
-			std::pair<MessageQueueId_t, EventMatchTree>(listener,
-					EventMatchTree(&factoryBackend, forwardAllButSelected)));
-	if (!result.second) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t EventManager::subscribeToEvent(MessageQueueId_t listener,
-		EventId_t event) {
-	return subscribeToEventRange(listener, event);
-}
-
-ReturnValue_t EventManager::subscribeToAllEventsFrom(MessageQueueId_t listener,
-		object_id_t object) {
-	return subscribeToEventRange(listener, 0, 0, true, object);
-}
-
-ReturnValue_t EventManager::subscribeToEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.addMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-ReturnValue_t EventManager::unsubscribeFromEventRange(MessageQueueId_t listener,
-		EventId_t idFrom, EventId_t idTo, bool idInverted,
-		object_id_t reporterFrom, object_id_t reporterTo,
-		bool reporterInverted) {
-	auto iter = listenerList.find(listener);
-	if (iter == listenerList.end()) {
-		return LISTENER_NOT_FOUND;
-	}
-	lockMutex();
-	ReturnValue_t result = iter->second.removeMatch(idFrom, idTo, idInverted,
-			reporterFrom, reporterTo, reporterInverted);
-	unlockMutex();
-	return result;
-}
-
-#if FSFW_OBJ_EVENT_TRANSLATION == 1
-
-void EventManager::printEvent(EventMessage* message) {
-	const char *string = 0;
-	switch (message->getSeverity()) {
-	case severity::INFO:
-#if DEBUG_INFO_EVENT == 1
-		string = translateObject(message->getReporter());
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::info << "EVENT: ";
-		if (string != 0) {
-			sif::info << string;
-		} else {
-			sif::info << "0x" << std::hex << message->getReporter() << std::dec;
-		}
-		sif::info << " reported " << translateEvents(message->getEvent()) << " ("
-				<< std::dec << message->getEventId() << std::hex << ") P1: 0x"
-				<< message->getParameter1() << " P2: 0x"
-				<< message->getParameter2() << std::dec << std::endl;
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif /* DEBUG_INFO_EVENT == 1 */
-		break;
-	default:
-		string = translateObject(message->getReporter());
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "EventManager: ";
-		if (string != 0) {
-			sif::debug << string;
-		}
-		else {
-			sif::debug << "0x" << std::hex << message->getReporter() << std::dec;
-		}
-		sif::debug << " reported " << translateEvents(message->getEvent())
-				<< " (" << std::dec << message->getEventId() << ") "
-				<< std::endl;
-		sif::debug << std::hex << "P1 Hex: 0x" << message->getParameter1()
-				<< ", P1 Dec: " << std::dec << message->getParameter1()
-				<< std::endl;
-		sif::debug << std::hex << "P2 Hex: 0x" << message->getParameter2()
-				<< ", P2 Dec: " <<  std::dec << message->getParameter2()
-				<< std::endl;
-#endif
-		break;
-	}
-}
-#endif
-
-void EventManager::lockMutex() {
-	mutex->lockMutex(timeoutType, timeoutMs);
-}
-
-void EventManager::unlockMutex() {
-	mutex->unlockMutex();
-}
-
-void EventManager::setMutexTimeout(MutexIF::TimeoutType timeoutType,
-		uint32_t timeoutMs) {
-	this->timeoutType = timeoutType;
-	this->timeoutMs = timeoutMs;
-}

events/fwSubsystemIdRanges.h

@@ -1,30 +0,0 @@
-#ifndef FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
-#define FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
-
-namespace SUBSYSTEM_ID {
-enum {
-	MEMORY = 22,
-	OBSW = 26,
-	CDH = 28,
-	TCS_1 = 59,
-	PCDU_1 = 42,
-	PCDU_2 = 43,
-	HEATER = 50,
-	T_SENSORS = 52,
-	FDIR = 70,
-	FDIR_1 = 71,
-	FDIR_2 = 72,
-	HK = 73,
-	SYSTEM_MANAGER = 74,
-	SYSTEM_MANAGER_1 = 75,
-	SYSTEM_1 = 79,
-	PUS_SERVICE_1 = 80,
-	PUS_SERVICE_9 = 89,
-	PUS_SERVICE_17 = 97,
-	FW_SUBSYSTEM_ID_RANGE
-};
-}
-
-
-
-#endif /* FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_ */

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_ */

globalfunctions/arrayprinter.cpp

@@ -1,77 +0,0 @@
-#include "arrayprinter.h"
-#include "../serviceinterface/ServiceInterface.h"
-#include <bitset>
-
-void arrayprinter::print(const uint8_t *data, size_t size, OutputType type,
-		bool printInfo, size_t maxCharPerLine) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	if(printInfo) {
-		sif::info << "Printing data with size " << size << ": ";
-	}
-	sif::info << "[";
-#else
-	sif::printInfo("Printing data with size %zu: [", size);
-#endif
-	if(type == OutputType::HEX) {
-		arrayprinter::printHex(data, size, maxCharPerLine);
-	}
-	else if (type == OutputType::DEC) {
-		arrayprinter::printDec(data, size, maxCharPerLine);
-	}
-	else if(type == OutputType::BIN) {
-	    arrayprinter::printBin(data, size);
-	}
-}
-
-void arrayprinter::printHex(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::info << std::hex;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << "0x" << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-
-			}
-		}
-	}
-	sif::info << std::dec;
-	sif::info << "]" << std::endl;
-#else
-	// how much memory to reserve for printout?
-#endif
-}
-
-void arrayprinter::printDec(const uint8_t *data, size_t size,
-		size_t maxCharPerLine) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::info << std::dec;
-	for(size_t i = 0; i < size; i++) {
-		sif::info << static_cast<int>(data[i]);
-		if(i < size - 1){
-			sif::info << " , ";
-			if(i > 0 and i % maxCharPerLine == 0) {
-				sif::info << std::endl;
-			}
-		}
-	}
-	sif::info << "]" << std::endl;
-#else
-	// how much memory to reserve for printout?
-#endif
-}
-
-void arrayprinter::printBin(const uint8_t *data, size_t size) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::info << "\n" << std::flush;
-    for(size_t i = 0; i < size; i++) {
-        sif::info << "Byte " << i + 1 << ": 0b"<<
-                std::bitset<8>(data[i]) << ",\n" << std::flush;
-    }
-    sif::info << "]" << std::endl;
-#else
-    // how much memory to reserve for printout?
-#endif
-}

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;
+}