From 9a3cd1d7fc5b069c655ba1bf53a8273df34b9bc8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 15:13:03 +0100
Subject: [PATCH 01/21] success flag not explicitely expected for actions

---
 action/ActionHelper.cpp                    | 6 +++---
 action/ActionHelper.h                      | 4 ++--
 action/ActionMessage.cpp                   | 7 ++++---
 action/ActionMessage.h                     | 8 ++++++--
 action/SimpleActionHelper.cpp              | 2 +-
 devicehandlers/DeviceHandlerBase.cpp       | 8 ++++++--
 unittest/tests/action/TestActionHelper.cpp | 2 +-
 7 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/action/ActionHelper.cpp b/action/ActionHelper.cpp
index e32be68b..42ee4022 100644
--- a/action/ActionHelper.cpp
+++ b/action/ActionHelper.cpp
@@ -43,10 +43,10 @@ void ActionHelper::step(uint8_t step, MessageQueueId_t reportTo,
     queueToUse->sendMessage(reportTo, &reply);
 }
 
-void ActionHelper::finish(MessageQueueId_t reportTo, ActionId_t commandId,
+void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t commandId,
         ReturnValue_t result) {
     CommandMessage reply;
-    ActionMessage::setCompletionReply(&reply, commandId, result);
+    ActionMessage::setCompletionReply(success, &reply, commandId, result);
     queueToUse->sendMessage(reportTo, &reply);
 }
 
@@ -69,7 +69,7 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy,
     ipcStore->deleteData(dataAddress);
     if(result == HasActionsIF::EXECUTION_FINISHED) {
         CommandMessage reply;
-        ActionMessage::setCompletionReply(&reply, actionId, result);
+        ActionMessage::setCompletionReply(true, &reply, actionId, result);
         queueToUse->sendMessage(commandedBy, &reply);
     }
     if (result != HasReturnvaluesIF::RETURN_OK) {
diff --git a/action/ActionHelper.h b/action/ActionHelper.h
index 35ac41d1..c9024747 100644
--- a/action/ActionHelper.h
+++ b/action/ActionHelper.h
@@ -62,12 +62,12 @@ public:
             ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
     /**
      * Function to be called by the owner to send a action completion message
-     *
+     * @param success   Specify whether action was completed successfully or not.
      * @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,
+    void finish(bool success, 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.
diff --git a/action/ActionMessage.cpp b/action/ActionMessage.cpp
index c3eb4710..15b59b9d 100644
--- a/action/ActionMessage.cpp
+++ b/action/ActionMessage.cpp
@@ -53,11 +53,12 @@ void ActionMessage::setDataReply(CommandMessage* message, ActionId_t actionId,
     message->setParameter2(data.raw);
 }
 
-void ActionMessage::setCompletionReply(CommandMessage* message,
+void ActionMessage::setCompletionReply(bool success, CommandMessage* message,
         ActionId_t fid, ReturnValue_t result) {
-    if (result == HasReturnvaluesIF::RETURN_OK or result == HasActionsIF::EXECUTION_FINISHED) {
+    if (success) {
         message->setCommand(COMPLETION_SUCCESS);
-    } else {
+    }
+    else {
         message->setCommand(COMPLETION_FAILED);
     }
     message->setParameter(fid);
diff --git a/action/ActionMessage.h b/action/ActionMessage.h
index 246ac601..df97485b 100644
--- a/action/ActionMessage.h
+++ b/action/ActionMessage.h
@@ -24,19 +24,23 @@ public:
     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 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,
+    static void setCompletionReply(bool success, CommandMessage* message, ActionId_t fid,
             ReturnValue_t result = HasReturnvaluesIF::RETURN_OK);
+
     static void clear(CommandMessage* message);
 };
 
diff --git a/action/SimpleActionHelper.cpp b/action/SimpleActionHelper.cpp
index f77d0147..979ee3ad 100644
--- a/action/SimpleActionHelper.cpp
+++ b/action/SimpleActionHelper.cpp
@@ -62,7 +62,7 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy,
         stepCount++;
         break;
     case HasActionsIF::EXECUTION_FINISHED:
-        ActionMessage::setCompletionReply(&reply, actionId,
+        ActionMessage::setCompletionReply(true, &reply, actionId,
                 HasReturnvaluesIF::RETURN_OK);
         queueToUse->sendMessage(commandedBy, &reply);
         break;
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 35d34bf9..15eac11f 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -558,7 +558,7 @@ void DeviceHandlerBase::replyToCommand(ReturnValue_t status,
     if (cookieInfo.pendingCommand->second.sendReplyTo != NO_COMMANDER) {
         MessageQueueId_t queueId = cookieInfo.pendingCommand->second.sendReplyTo;
         if (status == NO_REPLY_EXPECTED) {
-            actionHelper.finish(queueId, cookieInfo.pendingCommand->first,
+            actionHelper.finish(true, queueId, cookieInfo.pendingCommand->first,
                     RETURN_OK);
         } else {
             actionHelper.step(1, queueId, cookieInfo.pendingCommand->first,
@@ -581,7 +581,11 @@ void DeviceHandlerBase::replyToReply(DeviceReplyMap::iterator iter,
         // Check if it was transition or internal command.
         // Don't send any replies in that case.
         if (info->sendReplyTo != NO_COMMANDER) {
-            actionHelper.finish(info->sendReplyTo, iter->first, status);
+            bool success = false;
+            if(status == HasReturnvaluesIF::RETURN_OK) {
+                success = true;
+            }
+            actionHelper.finish(success, info->sendReplyTo, iter->first, status);
         }
         info->isExecuting = false;
     }
diff --git a/unittest/tests/action/TestActionHelper.cpp b/unittest/tests/action/TestActionHelper.cpp
index 2493a6b8..a7adfc82 100644
--- a/unittest/tests/action/TestActionHelper.cpp
+++ b/unittest/tests/action/TestActionHelper.cpp
@@ -70,7 +70,7 @@ TEST_CASE( "Action Helper" , "[ActionHelper]") {
 	SECTION("Handle finish"){
 		CHECK(not testMqMock.wasMessageSent());
 		ReturnValue_t status = 0x9876;
-		actionHelper.finish(testMqMock.getId(), testActionId, status);
+		actionHelper.finish(true, testMqMock.getId(), testActionId, status);
 		CHECK(testMqMock.wasMessageSent());
 		CommandMessage testMessage;
 		REQUIRE(testMqMock.receiveMessage(&testMessage) == static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));

From 6580aa73bf587afddcdfd908844dabe4add36489 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 17:13:37 +0100
Subject: [PATCH 02/21] updated clock module

---
 osal/FreeRTOS/Clock.cpp   | 214 +++++++++++++++++++-------------------
 timemanager/CCSDSTime.cpp |  16 ++-
 2 files changed, 119 insertions(+), 111 deletions(-)

diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 9c0a0267..806edcc7 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -16,56 +16,56 @@ uint16_t Clock::leapSeconds = 0;
 MutexIF* Clock::timeMutex = nullptr;
 
 uint32_t Clock::getTicksPerSecond(void) {
-	return 1000;
+    return 1000;
 }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 
-	timeval time_timeval;
+    timeval time_timeval;
 
-	ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK){
-		return result;
-	}
+    ReturnValue_t result = convertTimeOfDayToTimeval(time, &time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK){
+        return result;
+    }
 
-	return setClock(&time_timeval);
+    return setClock(&time_timeval);
 }
 
 ReturnValue_t Clock::setClock(const timeval* time) {
-	timeval uptime = getUptime();
+    timeval uptime = getUptime();
 
-	timeval offset = *time - uptime;
+    timeval offset = *time - uptime;
 
-	Timekeeper::instance()->setOffset(offset);
+    Timekeeper::instance()->setOffset(offset);
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getClock_timeval(timeval* time) {
-	timeval uptime = getUptime();
+    timeval uptime = getUptime();
 
-	timeval offset = Timekeeper::instance()->getOffset();
+    timeval offset = Timekeeper::instance()->getOffset();
 
-	*time = offset + uptime;
+    *time = offset + uptime;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
-	*uptime = getUptime();
+    *uptime = getUptime();
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 timeval Clock::getUptime() {
-	TickType_t ticksSinceStart = xTaskGetTickCount();
-	return Timekeeper::ticksToTimeval(ticksSinceStart);
+    TickType_t ticksSinceStart = xTaskGetTickCount();
+    return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-	timeval uptime = getUptime();
-	*uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
-	return HasReturnvaluesIF::RETURN_OK;
+    timeval uptime = getUptime();
+    *uptimeMs = uptime.tv_sec * 1000 + uptime.tv_usec / 1000;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 
@@ -76,129 +76,129 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 
 
 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
-	return HasReturnvaluesIF::RETURN_OK;
+    timeval time_timeval;
+    ReturnValue_t result = getClock_timeval(&time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *time = time_timeval.tv_sec * 1000000 + time_timeval.tv_usec;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-	timeval time_timeval;
-	ReturnValue_t result = getClock_timeval(&time_timeval);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	struct tm time_tm;
+    timeval time_timeval;
+    ReturnValue_t result = getClock_timeval(&time_timeval);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    struct tm time_tm;
 
-	gmtime_r(&time_timeval.tv_sec,&time_tm);
+    gmtime_r(&time_timeval.tv_sec,&time_tm);
 
-	time->year = time_tm.tm_year + 1900;
-	time->month = time_tm.tm_mon + 1;
-	time->day = time_tm.tm_mday;
+    time->year = time_tm.tm_year + 1900;
+    time->month = time_tm.tm_mon + 1;
+    time->day = time_tm.tm_mday;
 
-	time->hour = time_tm.tm_hour;
-	time->minute = time_tm.tm_min;
-	time->second = time_tm.tm_sec;
+    time->hour = time_tm.tm_hour;
+    time->minute = time_tm.tm_min;
+    time->second = time_tm.tm_sec;
 
-	time->usecond = time_timeval.tv_usec;
+    time->usecond = time_timeval.tv_usec;
 
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from,
-		timeval* to) {
-	struct tm time_tm;
+        timeval* to) {
+    struct tm time_tm;
 
-		time_tm.tm_year = from->year - 1900;
-		time_tm.tm_mon = from->month - 1;
-		time_tm.tm_mday = from->day;
+    time_tm.tm_year = from->year - 1900;
+    time_tm.tm_mon = from->month - 1;
+    time_tm.tm_mday = from->day;
 
-		time_tm.tm_hour = from->hour;
-		time_tm.tm_min = from->minute;
-		time_tm.tm_sec = from->second;
+    time_tm.tm_hour = from->hour;
+    time_tm.tm_min = from->minute;
+    time_tm.tm_sec = from->second;
 
-		time_t seconds = mktime(&time_tm);
+    time_t seconds = mktime(&time_tm);
 
-		to->tv_sec = seconds;
-		to->tv_usec = from->usecond;
-	//Fails in 2038..
-	return HasReturnvaluesIF::RETURN_OK;
+    to->tv_sec = seconds;
+    to->tv_usec = from->usecond;
+    //Fails in 2038..
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::convertTimevalToJD2000(timeval time, double* JD2000) {
-	*JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
-			/ 3600.;
-	return HasReturnvaluesIF::RETURN_OK;
+    *JD2000 = (time.tv_sec - 946728000. + time.tv_usec / 1000000.) / 24.
+            / 3600.;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
-	//SHOULDDO: works not for dates in the past (might have less leap seconds)
-	if (timeMutex == nullptr) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+    //SHOULDDO: works not for dates in the past (might have less leap seconds)
+    if (timeMutex == nullptr) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	uint16_t leapSeconds;
-	ReturnValue_t result = getLeapSeconds(&leapSeconds);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	timeval leapSeconds_timeval = { 0, 0 };
-	leapSeconds_timeval.tv_sec = leapSeconds;
+    uint16_t leapSeconds;
+    ReturnValue_t result = getLeapSeconds(&leapSeconds);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    timeval leapSeconds_timeval = { 0, 0 };
+    leapSeconds_timeval.tv_sec = leapSeconds;
 
-	//initial offset between UTC and TAI
-	timeval UTCtoTAI1972 = { 10, 0 };
+    //initial offset between UTC and TAI
+    timeval UTCtoTAI1972 = { 10, 0 };
 
-	timeval TAItoTT = { 32, 184000 };
+    timeval TAItoTT = { 32, 184000 };
 
-	*tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
+    *tt = utc + leapSeconds_timeval + UTCtoTAI1972 + TAItoTT;
 
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
-	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	leapSeconds = leapSeconds_;
+    leapSeconds = leapSeconds_;
 
-	result = timeMutex->unlockMutex();
-	return result;
+    result = timeMutex->unlockMutex();
+    return result;
 }
 
 ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
-	if (timeMutex == NULL) {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
+    if (timeMutex == NULL) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    ReturnValue_t result = timeMutex->lockMutex(MutexIF::TimeoutType::BLOCKING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
 
-	*leapSeconds_ = leapSeconds;
+    *leapSeconds_ = leapSeconds;
 
-	result = timeMutex->unlockMutex();
-	return result;
+    result = timeMutex->unlockMutex();
+    return result;
 }
 
 ReturnValue_t Clock::checkOrCreateClockMutex() {
-	if (timeMutex == NULL) {
-		MutexFactory* mutexFactory = MutexFactory::instance();
-		if (mutexFactory == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		timeMutex = mutexFactory->createMutex();
-		if (timeMutex == NULL) {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if (timeMutex == NULL) {
+        MutexFactory* mutexFactory = MutexFactory::instance();
+        if (mutexFactory == NULL) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        timeMutex = mutexFactory->createMutex();
+        if (timeMutex == NULL) {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index aefcac2e..8f0d1c31 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -396,12 +396,20 @@ ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
 		size_t* foundLength, size_t maxLength) {
-	//We don't expect ascii here. SHOULDDO
+    if(maxLength >= 19) {
+        Clock::TimeOfDay_t timeOfDay;
+        /* Try to parse it as ASCII */
+        ReturnValue_t result = convertFromASCII(&timeOfDay, from, maxLength);
+        if (result == RETURN_OK) {
+            return Clock::convertTimeOfDayToTimeval(&timeOfDay, to);
+        }
+    }
+
 	uint8_t codeIdentification = (*from >> 4);
 	switch (codeIdentification) {
-	//unsupported, as Leap second correction would have to be applied
-//	case CUC_LEVEL1:
-//		return convertFromCUC(to, from, foundLength, maxLength);
+	/* Unsupported, as Leap second correction would have to be applied */
+	case CUC_LEVEL1:
+		return UNSUPPORTED_TIME_FORMAT;
 	case CDS:
 		return convertFromCDS(to, from, foundLength, maxLength);
 	case CCS:

From bff8d103ba77837b63b91577ff30c52926d625ef Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 22:45:44 +0100
Subject: [PATCH 03/21] form stuff and cleaning up

---
 datapoollocal/LocalDataPoolManager.cpp |  8 ++++----
 datapoollocal/LocalPoolVariable.tpp    | 10 ----------
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp
index c15182d2..72873d99 100644
--- a/datapoollocal/LocalDataPoolManager.cpp
+++ b/datapoollocal/LocalDataPoolManager.cpp
@@ -42,15 +42,15 @@ 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);
+		/* 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
+		/* Error, all destinations invalid */
 		printWarningOrError(sif::OutputTypes::OUT_ERROR,
 				"initialize", HasReturnvaluesIF::RETURN_FAILED,
 				"Could not set IPC store.");
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index 35de4ebd..aa789a6d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -43,7 +43,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
     PoolEntry<T>* poolEntry = nullptr;
     ReturnValue_t result = LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId,
             &poolEntry);
-    //ReturnValue_t result = hkManager->fetchPoolEntry(localPoolId, &poolEntry);
     if(result != RETURN_OK) {
         object_id_t ownerObjectId = hkManager->getCreatorObjectId();
         reportReadCommitError("LocalPoolVariable", result,
@@ -51,15 +50,6 @@ inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
         return result;
     }
 
-    // Actually this should never happen..
-    //	if(poolEntry->address == nullptr) {
-    //		result = PoolVariableIF::INVALID_POOL_ENTRY;
-    //		object_id_t ownerObjectId = hkManager->getOwner()->getObjectId();
-    //		reportReadCommitError("LocalPoolVariable", result,
-    //				false, ownerObjectId, localPoolId);
-    //		return result;
-    //	}
-
     this->value = *(poolEntry->getDataPtr());
     this->valid = poolEntry->getValid();
     return RETURN_OK;

From d8d18c93335f3e850deda56aa10ace757d8e6c2a Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Wed, 3 Mar 2021 23:49:27 +0100
Subject: [PATCH 04/21] fixed order

---
 controller/ExtendedControllerBase.cpp  | 8 +++++---
 datapoollocal/LocalPoolDataSetBase.cpp | 3 +--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/controller/ExtendedControllerBase.cpp b/controller/ExtendedControllerBase.cpp
index cc93efa8..95ba012e 100644
--- a/controller/ExtendedControllerBase.cpp
+++ b/controller/ExtendedControllerBase.cpp
@@ -13,7 +13,7 @@ ExtendedControllerBase::~ExtendedControllerBase() {
 
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
         MessageQueueId_t commandedBy, const uint8_t *data, size_t size) {
-    // needs to be overriden and implemented by child class.
+    /* Needs to be overriden and implemented by child class. */
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -21,7 +21,7 @@ ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
 
 ReturnValue_t ExtendedControllerBase::initializeLocalDataPool(
         localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
-    // needs to be overriden and implemented by child class.
+    /* Needs to be overriden and implemented by child class. */
     return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -96,8 +96,10 @@ ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
     handleQueue();
-    poolManager.performHkOperation();
     performControlOperation();
+    /* We do this after performing control operation because variables will be set changed
+    in this function. */
+    poolManager.performHkOperation();
     return RETURN_OK;
 }
 
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index 75a3ab7c..d043d18f 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -42,8 +42,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
     }
 }
 
-LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid,
-        PoolVariableIF** registeredVariablesArray,
+LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
                 PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(

From dae4a5fa7447dbd9bf49242facbd4c20509e8dc4 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:36:34 +0100
Subject: [PATCH 05/21] small form stuff

---
 datapoollocal/HasLocalDataPoolIF.h   | 4 ++--
 datapoollocal/LocalPoolDataSetBase.h | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/datapoollocal/HasLocalDataPoolIF.h b/datapoollocal/HasLocalDataPoolIF.h
index 49f2db7d..d52c72b6 100644
--- a/datapoollocal/HasLocalDataPoolIF.h
+++ b/datapoollocal/HasLocalDataPoolIF.h
@@ -162,8 +162,8 @@ protected:
      */
     virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden"
-                << ". Returning nullptr!" << std::endl;
+        sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
+                "Returning nullptr!" << std::endl;
 #else
         sif::printWarning("HasLocalDataPoolIF::getPoolObjectHandle: "
                 "Not overriden. Returning nullptr!\n");
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 8a3a6339..9501f782 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -59,7 +59,7 @@ public:
 
     /**
      * @brief	Constructor for users of the local pool data, which need
-     *          to access data created by one (!) HK manager.
+     *          to access data created by one HK manager.
      * @details
      * Unlike the first constructor, no component for periodic handling
      * will be initiated.

From 21a7fd621d69d1058a2a55ddc6a4867021b0fb85 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:38:35 +0100
Subject: [PATCH 06/21] renamed guard class

---
 datapool/{PoolReadHelper.h => PoolReadGuard.h}    | 6 +++---
 unittest/tests/datapoollocal/LocalPoolOwnerBase.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)
 rename datapool/{PoolReadHelper.h => PoolReadGuard.h} (94%)

diff --git a/datapool/PoolReadHelper.h b/datapool/PoolReadGuard.h
similarity index 94%
rename from datapool/PoolReadHelper.h
rename to datapool/PoolReadGuard.h
index 9825e83c..eb014f1e 100644
--- a/datapool/PoolReadHelper.h
+++ b/datapool/PoolReadGuard.h
@@ -8,9 +8,9 @@
 /**
  * @brief 	Helper class to read data sets or pool variables
  */
-class PoolReadHelper {
+class PoolReadGuard {
 public:
-    PoolReadHelper(ReadCommitIF* readObject,
+    PoolReadGuard(ReadCommitIF* readObject,
             MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
             uint32_t mutexTimeout = 20):
                 readObject(readObject), mutexTimeout(mutexTimeout) {
@@ -42,7 +42,7 @@ public:
     /**
      * @brief   Default destructor which will take care of commiting changed values.
      */
-    ~PoolReadHelper() {
+    ~PoolReadGuard() {
         if(readObject != nullptr and not noCommit) {
             readObject->commit(timeoutType, mutexTimeout);
         }
diff --git a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
index bb090e3b..5c277850 100644
--- a/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
+++ b/unittest/tests/datapoollocal/LocalPoolOwnerBase.h
@@ -192,7 +192,7 @@ public:
         resetSubscriptionList();
         ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
         {
-            PoolReadHelper readHelper(&dataset);
+            PoolReadGuard readHelper(&dataset);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }
@@ -205,7 +205,7 @@ public:
         }
 
         {
-            PoolReadHelper readHelper(&testUint32);
+            PoolReadGuard readHelper(&testUint32);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }
@@ -214,7 +214,7 @@ public:
         }
 
         {
-            PoolReadHelper readHelper(&testInt64Vec);
+            PoolReadGuard readHelper(&testInt64Vec);
             if(readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
                 status = readHelper.getReadResult();
             }

From d66e486f166f3a9d926be4f270a22caf37f6243e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:44:17 +0100
Subject: [PATCH 07/21] whitespaces instead of tabs

---
 timemanager/CCSDSTime.cpp | 954 +++++++++++++++++++-------------------
 timemanager/CCSDSTime.h   | 370 +++++++--------
 2 files changed, 662 insertions(+), 662 deletions(-)

diff --git a/timemanager/CCSDSTime.cpp b/timemanager/CCSDSTime.cpp
index 8f0d1c31..192c1f57 100644
--- a/timemanager/CCSDSTime.cpp
+++ b/timemanager/CCSDSTime.cpp
@@ -12,390 +12,390 @@ CCSDSTime::~CCSDSTime() {
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_seconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        const Clock::TimeOfDay_t* from) {
+    ReturnValue_t result = checkTimeOfDay(from);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	to->pField = (CCS << 4);
+    to->pField = (CCS << 4);
 
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
+    to->yearMSB = (from->year >> 8);
+    to->yearLSB = from->year & 0xff;
+    to->month = from->month;
+    to->day = from->day;
+    to->hour = from->hour;
+    to->minute = from->minute;
+    to->second = from->second;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(Ccs_mseconds* to,
-		const Clock::TimeOfDay_t* from) {
-	ReturnValue_t result = checkTimeOfDay(from);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        const Clock::TimeOfDay_t* from) {
+    ReturnValue_t result = checkTimeOfDay(from);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	to->pField = (CCS << 4) + 2;
+    to->pField = (CCS << 4) + 2;
 
-	to->yearMSB = (from->year >> 8);
-	to->yearLSB = from->year & 0xff;
-	to->month = from->month;
-	to->day = from->day;
-	to->hour = from->hour;
-	to->minute = from->minute;
-	to->second = from->second;
-	to->secondEminus2 = from->usecond / 10000;
-	to->secondEminus4 = (from->usecond % 10000) / 100;
+    to->yearMSB = (from->year >> 8);
+    to->yearLSB = from->year & 0xff;
+    to->month = from->month;
+    to->day = from->day;
+    to->hour = from->hour;
+    to->minute = from->minute;
+    to->second = from->second;
+    to->secondEminus2 = from->usecond / 10000;
+    to->secondEminus4 = (from->usecond % 10000) / 100;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(Clock::TimeOfDay_t* to,
         const uint8_t* from, size_t length) {
-	ReturnValue_t result;
-	if (length > 0xFF) {
-		return LENGTH_MISMATCH;
-	}
-	result = convertFromASCII(to, from, length); //Try to parse it as ASCII
-	if (result == RETURN_OK) {
-		return RETURN_OK;
-	}
+    ReturnValue_t result;
+    if (length > 0xFF) {
+        return LENGTH_MISMATCH;
+    }
+    result = convertFromASCII(to, from, length); //Try to parse it as ASCII
+    if (result == RETURN_OK) {
+        return RETURN_OK;
+    }
 
-	//Seems to be no ascii, try the other formats
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
-		return convertFromCUC(to, from, length);
-	case CDS:
-		return convertFromCDS(to, from, length);
-	case CCS: {
-		size_t temp = 0;
-		return convertFromCCS(to, from, &temp, length);
-	}
+    //Seems to be no ascii, try the other formats
+    uint8_t codeIdentification = (*from >> 4);
+    switch (codeIdentification) {
+    case CUC_LEVEL1: //CUC_LEVEL2 can not be converted to TimeOfDay (ToD is Level 1) <- Well, if we know the epoch, we can... <- see bug 1133
+        return convertFromCUC(to, from, length);
+    case CDS:
+        return convertFromCDS(to, from, length);
+    case CCS: {
+        size_t temp = 0;
+        return convertFromCCS(to, from, &temp, length);
+    }
 
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
+    default:
+        return UNSUPPORTED_TIME_FORMAT;
+    }
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	return UNSUPPORTED_TIME_FORMAT;
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	timeval time;
-	ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	return convertTimevalToTimeOfDay(to, &time);
+    timeval time;
+    ReturnValue_t result = convertFromCDS(&time, from, NULL, length);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return convertTimevalToTimeOfDay(to, &time);
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to,
         const uint8_t* from, size_t* foundLength, size_t maxLength) {
-	uint8_t subsecondsLength = *from & 0b111;
-	uint32_t totalLength = subsecondsLength + 8;
-	if (maxLength < totalLength) {
-		return LENGTH_MISMATCH;
-	}
+    uint8_t subsecondsLength = *from & 0b111;
+    uint32_t totalLength = subsecondsLength + 8;
+    if (maxLength < totalLength) {
+        return LENGTH_MISMATCH;
+    }
 
-	*foundLength = totalLength;
+    *foundLength = totalLength;
 
-	ReturnValue_t result = checkCcs(from, maxLength);
+    ReturnValue_t result = checkCcs(from, maxLength);
 
-	if (result != RETURN_OK) {
-		return result;
-	}
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	Ccs_mseconds *temp = (Ccs_mseconds *) from;
+    Ccs_mseconds *temp = (Ccs_mseconds *) from;
 
-	to->year = (temp->yearMSB << 8) + temp->yearLSB;
-	to->hour = temp->hour;
-	to->minute = temp->minute;
-	to->second = temp->second;
+    to->year = (temp->yearMSB << 8) + temp->yearLSB;
+    to->hour = temp->hour;
+    to->minute = temp->minute;
+    to->second = temp->second;
 
-	if (temp->pField & (1 << 3)) { //day of year variation
-		uint16_t tempDay = (temp->month << 8) + temp->day;
-		result = convertDaysOfYear(tempDay, to->year,
-				&(temp->month), &(temp->day));
-		if (result != RETURN_OK) {
-			return result;
-		}
-	}
+    if (temp->pField & (1 << 3)) { //day of year variation
+        uint16_t tempDay = (temp->month << 8) + temp->day;
+        result = convertDaysOfYear(tempDay, to->year,
+                &(temp->month), &(temp->day));
+        if (result != RETURN_OK) {
+            return result;
+        }
+    }
 
-	to->month = temp->month;
-	to->day = temp->day;
+    to->month = temp->month;
+    to->day = temp->day;
 
-	to->usecond = 0;
-	if (subsecondsLength > 0) {
-		*foundLength += 1;
-		if (temp->secondEminus2 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond = temp->secondEminus2 * 10000;
-	}
+    to->usecond = 0;
+    if (subsecondsLength > 0) {
+        *foundLength += 1;
+        if (temp->secondEminus2 >= 100) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->usecond = temp->secondEminus2 * 10000;
+    }
 
-	if (subsecondsLength > 1) {
-		*foundLength += 1;
-		if (temp->secondEminus4 >= 100) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->usecond += temp->secondEminus4 * 100;
-	}
+    if (subsecondsLength > 1) {
+        *foundLength += 1;
+        if (temp->secondEminus4 >= 100) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->usecond += temp->secondEminus4 * 100;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 
 }
 
 ReturnValue_t CCSDSTime::convertFromASCII(Clock::TimeOfDay_t* to,
         const uint8_t* from, uint8_t length) {
-	if (length < 19) {
-		return RETURN_FAILED;
-	}
-// Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
-// Suggestion: use uint16 all the time. This should work on all systems.
+    if (length < 19) {
+        return RETURN_FAILED;
+    }
+    // Newlib nano can't parse uint8, see SCNu8 documentation and https://sourceware.org/newlib/README
+    // Suggestion: use uint16 all the time. This should work on all systems.
 #if FSFW_NO_C99_IO == 1
-	uint16_t year;
-	uint16_t month;
-	uint16_t day;
-	uint16_t hour;
-	uint16_t minute;
-	float second;
-	int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
-	        "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
-	        &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    uint16_t year;
+    uint16_t month;
+    uint16_t day;
+    uint16_t hour;
+    uint16_t minute;
+    float second;
+    int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu16 "-%2" SCNu16 "T%"
+            "2" SCNu16 ":%2" SCNu16 ":%fZ", &year, &month, &day, &hour,
+            &minute, &second);
+    if (count == 6) {
+        to->year = year;
+        to->month = month;
+        to->day = day;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 
-	// try Code B (yyyy-ddd)
-	count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
-	        "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
-				reinterpret_cast<uint8_t *>(&month),
-				reinterpret_cast<uint8_t *>(&tempDay));
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
-// Warning: Compiler/Linker fails ambiguously if library does not implement
-// C99 I/O
+    // try Code B (yyyy-ddd)
+    count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu16 ":%"
+            "2" SCNu16 ":%fZ", &year, &day, &hour, &minute, &second);
+    if (count == 5) {
+        uint8_t tempDay;
+        ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year,
+                reinterpret_cast<uint8_t *>(&month),
+                reinterpret_cast<uint8_t *>(&tempDay));
+        if (result != RETURN_OK) {
+            return RETURN_FAILED;
+        }
+        to->year = year;
+        to->month = month;
+        to->day = tempDay;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
+    // Warning: Compiler/Linker fails ambiguously if library does not implement
+    // C99 I/O
 #else
-	uint16_t year;
-	uint8_t month;
-	uint16_t day;
-	uint8_t hour;
-	uint8_t minute;
-	float second;
+    uint16_t year;
+    uint8_t month;
+    uint16_t day;
+    uint8_t hour;
+    uint8_t minute;
+    float second;
     //try Code A (yyyy-mm-dd)
     int count = sscanf((char *) from, "%4" SCNu16 "-%2" SCNu8 "-%2" SCNu16
             "T%2" SCNu8 ":%2" SCNu8 ":%fZ", &year, &month, &day,
             &hour, &minute, &second);
-	if (count == 6) {
-		to->year = year;
-		to->month = month;
-		to->day = day;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    if (count == 6) {
+        to->year = year;
+        to->month = month;
+        to->day = day;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 
     //try Code B (yyyy-ddd)
     count = sscanf((char *) from, "%4" SCNu16 "-%3" SCNu16 "T%2" SCNu8
             ":%2" SCNu8 ":%fZ", &year, &day, &hour, &minute, &second);
-	if (count == 5) {
-		uint8_t tempDay;
-		ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
-				&tempDay);
-		if (result != RETURN_OK) {
-			return RETURN_FAILED;
-		}
-		to->year = year;
-		to->month = month;
-		to->day = tempDay;
-		to->hour = hour;
-		to->minute = minute;
-		to->second = second;
-		to->usecond = (second - floor(second)) * 1000000;
-		return RETURN_OK;
-	}
+    if (count == 5) {
+        uint8_t tempDay;
+        ReturnValue_t result = CCSDSTime::convertDaysOfYear(day, year, &month,
+                &tempDay);
+        if (result != RETURN_OK) {
+            return RETURN_FAILED;
+        }
+        to->year = year;
+        to->month = month;
+        to->day = tempDay;
+        to->hour = hour;
+        to->minute = minute;
+        to->second = second;
+        to->usecond = (second - floor(second)) * 1000000;
+        return RETURN_OK;
+    }
 #endif
 
-	return UNSUPPORTED_TIME_FORMAT;
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::checkCcs(const uint8_t* time, uint8_t length) {
-	Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
+    Ccs_mseconds *time_struct = (Ccs_mseconds *) time;
 
-	uint8_t additionalBytes = time_struct->pField & 0b111;
-	if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
-		return INVALID_TIME_FORMAT;
-	}
+    uint8_t additionalBytes = time_struct->pField & 0b111;
+    if ((additionalBytes == 0b111) || (length < (additionalBytes + 8))) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time_struct->pField & (1 << 3)) { //day of year variation
-		uint16_t day = (time_struct->month << 8) + time_struct->day;
-		if (day > 366) {
-			return INVALID_TIME_FORMAT;
-		}
-	} else {
-		if (time_struct->month > 12) {
-			return INVALID_TIME_FORMAT;
-		}
-		if (time_struct->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	if (time_struct->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
-	if (time_struct->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time_struct->pField & (1 << 3)) { //day of year variation
+        uint16_t day = (time_struct->month << 8) + time_struct->day;
+        if (day > 366) {
+            return INVALID_TIME_FORMAT;
+        }
+    } else {
+        if (time_struct->month > 12) {
+            return INVALID_TIME_FORMAT;
+        }
+        if (time_struct->day > 31) {
+            return INVALID_TIME_FORMAT;
+        }
+    }
+    if (time_struct->hour > 23) {
+        return INVALID_TIME_FORMAT;
+    }
+    if (time_struct->minute > 59) {
+        return INVALID_TIME_FORMAT;
+    }
+    if (time_struct->second > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	uint8_t *additionalByte = &time_struct->secondEminus2;
+    uint8_t *additionalByte = &time_struct->secondEminus2;
 
-	for (; additionalBytes != 0; additionalBytes--) {
-		if (*additionalByte++ > 99) {
-			return INVALID_TIME_FORMAT;
-		}
-	}
-	return RETURN_OK;
+    for (; additionalBytes != 0; additionalBytes--) {
+        if (*additionalByte++ > 99) {
+            return INVALID_TIME_FORMAT;
+        }
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-		uint8_t* month, uint8_t* day) {
-	if (isLeapYear(year)) {
-		if (dayofYear > 366) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	} else {
-		if (dayofYear > 365) {
-			return INVALID_DAY_OF_YEAR;
-		}
-	}
-	*month = 1;
-	if (dayofYear <= 31) {
-		*day = dayofYear;
-		return RETURN_OK;
-	}
-	*month += 1;
-	dayofYear -= 31;
-	if (isLeapYear(year)) {
-		if (dayofYear <= 29) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 29;
-	} else {
-		if (dayofYear <= 28) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 28;
-	}
-	while (*month <= 12) {
-		if (dayofYear <= 31) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 31;
+        uint8_t* month, uint8_t* day) {
+    if (isLeapYear(year)) {
+        if (dayofYear > 366) {
+            return INVALID_DAY_OF_YEAR;
+        }
+    } else {
+        if (dayofYear > 365) {
+            return INVALID_DAY_OF_YEAR;
+        }
+    }
+    *month = 1;
+    if (dayofYear <= 31) {
+        *day = dayofYear;
+        return RETURN_OK;
+    }
+    *month += 1;
+    dayofYear -= 31;
+    if (isLeapYear(year)) {
+        if (dayofYear <= 29) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 29;
+    } else {
+        if (dayofYear <= 28) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 28;
+    }
+    while (*month <= 12) {
+        if (dayofYear <= 31) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 31;
 
-		if (*month == 8) {
-			continue;
-		}
+        if (*month == 8) {
+            continue;
+        }
 
-		if (dayofYear <= 30) {
-			*day = dayofYear;
-			return RETURN_OK;
-		}
-		*month += 1;
-		dayofYear -= 30;
-	}
-	return INVALID_DAY_OF_YEAR;
+        if (dayofYear <= 30) {
+            *day = dayofYear;
+            return RETURN_OK;
+        }
+        *month += 1;
+        dayofYear -= 30;
+    }
+    return INVALID_DAY_OF_YEAR;
 }
 
 bool CCSDSTime::isLeapYear(uint32_t year) {
-	if ((year % 400) == 0) {
-		return true;
-	}
-	if ((year % 100) == 0) {
-		return false;
-	}
-	if ((year % 4) == 0) {
-		return true;
-	}
-	return false;
+    if ((year % 400) == 0) {
+        return true;
+    }
+    if ((year % 100) == 0) {
+        return false;
+    }
+    if ((year % 4) == 0) {
+        return true;
+    }
+    return false;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(CDS_short* to, const timeval* from) {
-	to->pField = (CDS << 4) + 0;
-	uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
-			+ DAYS_CCSDS_TO_UNIX_EPOCH;
-	if (days > (1 << 16)) {
-		//Date is beyond year 2137
-		return TIME_DOES_NOT_FIT_FORMAT;
-	}
-	to->dayMSB = (days & 0xFF00) >> 8;
-	to->dayLSB = (days & 0xFF);
-	uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
-			+ (from->tv_usec / 1000);
-	to->msDay_hh = (msDay & 0xFF000000) >> 24;
-	to->msDay_h = (msDay & 0xFF0000) >> 16;
-	to->msDay_l = (msDay & 0xFF00) >> 8;
-	to->msDay_ll = (msDay & 0xFF);
-	return RETURN_OK;
+    to->pField = (CDS << 4) + 0;
+    uint32_t days = ((from->tv_sec) / SECONDS_PER_DAY)
+			        + DAYS_CCSDS_TO_UNIX_EPOCH;
+    if (days > (1 << 16)) {
+        //Date is beyond year 2137
+        return TIME_DOES_NOT_FIT_FORMAT;
+    }
+    to->dayMSB = (days & 0xFF00) >> 8;
+    to->dayLSB = (days & 0xFF);
+    uint32_t msDay = ((from->tv_sec % SECONDS_PER_DAY) * 1000)
+			        + (from->tv_usec / 1000);
+    to->msDay_hh = (msDay & 0xFF000000) >> 24;
+    to->msDay_h = (msDay & 0xFF0000) >> 16;
+    to->msDay_l = (msDay & 0xFF00) >> 8;
+    to->msDay_ll = (msDay & 0xFF);
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertToCcsds(OBT_FLP* to, const timeval* from) {
-	to->pFiled = (AGENCY_DEFINED << 4) + 5;
-	to->seconds_hh = (from->tv_sec >> 24) & 0xff;
-	to->seconds_h = (from->tv_sec >> 16) & 0xff;
-	to->seconds_l = (from->tv_sec >> 8) & 0xff;
-	to->seconds_ll = (from->tv_sec >> 0) & 0xff;
+    to->pFiled = (AGENCY_DEFINED << 4) + 5;
+    to->seconds_hh = (from->tv_sec >> 24) & 0xff;
+    to->seconds_h = (from->tv_sec >> 16) & 0xff;
+    to->seconds_l = (from->tv_sec >> 8) & 0xff;
+    to->seconds_ll = (from->tv_sec >> 0) & 0xff;
 
-	//convert the µs to 2E-16 seconds
-	uint64_t temp = from->tv_usec;
-	temp = temp << 16;
-	temp = temp / 1E6;
+    //convert the µs to 2E-16 seconds
+    uint64_t temp = from->tv_usec;
+    temp = temp << 16;
+    temp = temp / 1E6;
 
-	to->subsecondsMSB = (temp >> 8) & 0xff;
-	to->subsecondsLSB = temp & 0xff;
+    to->subsecondsMSB = (temp >> 8) & 0xff;
+    to->subsecondsLSB = temp & 0xff;
 
-	return RETURN_OK;
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
+        size_t* foundLength, size_t maxLength) {
     if(maxLength >= 19) {
         Clock::TimeOfDay_t timeOfDay;
         /* Try to parse it as ASCII */
@@ -405,210 +405,210 @@ ReturnValue_t CCSDSTime::convertFromCcsds(timeval* to, const uint8_t* from,
         }
     }
 
-	uint8_t codeIdentification = (*from >> 4);
-	switch (codeIdentification) {
-	/* Unsupported, as Leap second correction would have to be applied */
-	case CUC_LEVEL1:
-		return UNSUPPORTED_TIME_FORMAT;
-	case CDS:
-		return convertFromCDS(to, from, foundLength, maxLength);
-	case CCS:
-		return convertFromCCS(to, from, foundLength, maxLength);
-	default:
-		return UNSUPPORTED_TIME_FORMAT;
-	}
+    uint8_t codeIdentification = (*from >> 4);
+    switch (codeIdentification) {
+    /* Unsupported, as Leap second correction would have to be applied */
+    case CUC_LEVEL1:
+        return UNSUPPORTED_TIME_FORMAT;
+    case CDS:
+        return convertFromCDS(to, from, foundLength, maxLength);
+    case CCS:
+        return convertFromCCS(to, from, foundLength, maxLength);
+    default:
+        return UNSUPPORTED_TIME_FORMAT;
+    }
 
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	if (maxLength < 1) {
-		return INVALID_TIME_FORMAT;
-	}
-	uint8_t pField = *from;
-	from++;
-	ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
-			maxLength - 1);
-	if (result == HasReturnvaluesIF::RETURN_OK) {
-		if (foundLength != NULL) {
-			*foundLength += 1;
-		}
-	}
-	return result;
+        size_t* foundLength, size_t maxLength) {
+    if (maxLength < 1) {
+        return INVALID_TIME_FORMAT;
+    }
+    uint8_t pField = *from;
+    from++;
+    ReturnValue_t result = convertFromCUC(to, pField, from, foundLength,
+            maxLength - 1);
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+        if (foundLength != NULL) {
+            *foundLength += 1;
+        }
+    }
+    return result;
 }
 
 ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
-	if ((time->month > 12) || (time->month == 0)) {
-		return INVALID_TIME_FORMAT;
-	}
+    if ((time->month > 12) || (time->month == 0)) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->day == 0) {
-		return INVALID_TIME_FORMAT;
-	}
-	switch (time->month) {
-	case 2:
-		if (isLeapYear(time->year)) {
-			if (time->day > 29) {
-				return INVALID_TIME_FORMAT;
-			}
-		} else {
-			if (time->day > 28) {
-				return INVALID_TIME_FORMAT;
-			}
-		}
-		break;
-	case 4:
-	case 6:
-	case 9:
-	case 11:
-		if (time->day > 30) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	default:
-		if (time->day > 31) {
-			return INVALID_TIME_FORMAT;
-		}
-		break;
-	}
+    if (time->day == 0) {
+        return INVALID_TIME_FORMAT;
+    }
+    switch (time->month) {
+    case 2:
+        if (isLeapYear(time->year)) {
+            if (time->day > 29) {
+                return INVALID_TIME_FORMAT;
+            }
+        } else {
+            if (time->day > 28) {
+                return INVALID_TIME_FORMAT;
+            }
+        }
+        break;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+        if (time->day > 30) {
+            return INVALID_TIME_FORMAT;
+        }
+        break;
+    default:
+        if (time->day > 31) {
+            return INVALID_TIME_FORMAT;
+        }
+        break;
+    }
 
-	if (time->hour > 23) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->hour > 23) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->minute > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->minute > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->second > 59) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->second > 59) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	if (time->usecond > 999999) {
-		return INVALID_TIME_FORMAT;
-	}
+    if (time->usecond > 999999) {
+        return INVALID_TIME_FORMAT;
+    }
 
-	return RETURN_OK;
+    return RETURN_OK;
 
 }
 
 ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-		timeval* from) {
-//This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-	return UNSUPPORTED_TIME_FORMAT;
+        timeval* from) {
+    //This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
+    return UNSUPPORTED_TIME_FORMAT;
 }
 
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	uint8_t pField = *from;
-	from++;
-//Check epoch
-	if (pField & 0b1000) {
-		return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
-	}
-//Check length
-	uint8_t expectedLength = 7; //Including p-Field.
-	bool extendedDays = pField & 0b100;
-	if (extendedDays) {
-		expectedLength += 1;
-	}
-	if ((pField & 0b11) == 0b01) {
-		expectedLength += 2;
-	} else if ((pField & 0b11) == 0b10) {
-		expectedLength += 4;
-	}
-	if (foundLength != NULL) {
-		*foundLength = expectedLength;
-	}
-	if (expectedLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-//Check and count days
-	uint32_t days = 0;
-	if (extendedDays) {
-		days = (from[0] << 16) + (from[1] << 8) + from[2];
-		from += 3;
-	} else {
-		days = (from[0] << 8) + from[1];
-		from += 2;
-	}
-//Move to POSIX epoch.
-	if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
-		return INVALID_TIME_FORMAT;
-	}
-	days -= DAYS_CCSDS_TO_UNIX_EPOCH;
-	to->tv_sec = days * SECONDS_PER_DAY;
-	uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-			+ from[3];
-	from += 4;
-	to->tv_sec += (msDay / 1000);
-	to->tv_usec = (msDay % 1000) * 1000;
-	if ((pField & 0b11) == 0b01) {
-		uint16_t usecs = (from[0] << 16) + from[1];
-		from += 2;
-		if (usecs > 999) {
-			return INVALID_TIME_FORMAT;
-		}
-		to->tv_usec += usecs;
-	} else if ((pField & 0b11) == 0b10) {
-		uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
-				+ from[3];
-		from += 4;
-		if (picosecs > 999999) {
-			return INVALID_TIME_FORMAT;
-		}
-		//Not very useful.
-		to->tv_usec += (picosecs / 1000);
-	}
-	return RETURN_OK;
+        size_t* foundLength, size_t maxLength) {
+    uint8_t pField = *from;
+    from++;
+    //Check epoch
+    if (pField & 0b1000) {
+        return NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT;
+    }
+    //Check length
+    uint8_t expectedLength = 7; //Including p-Field.
+    bool extendedDays = pField & 0b100;
+    if (extendedDays) {
+        expectedLength += 1;
+    }
+    if ((pField & 0b11) == 0b01) {
+        expectedLength += 2;
+    } else if ((pField & 0b11) == 0b10) {
+        expectedLength += 4;
+    }
+    if (foundLength != NULL) {
+        *foundLength = expectedLength;
+    }
+    if (expectedLength > maxLength) {
+        return LENGTH_MISMATCH;
+    }
+    //Check and count days
+    uint32_t days = 0;
+    if (extendedDays) {
+        days = (from[0] << 16) + (from[1] << 8) + from[2];
+        from += 3;
+    } else {
+        days = (from[0] << 8) + from[1];
+        from += 2;
+    }
+    //Move to POSIX epoch.
+    if (days <= DAYS_CCSDS_TO_UNIX_EPOCH) {
+        return INVALID_TIME_FORMAT;
+    }
+    days -= DAYS_CCSDS_TO_UNIX_EPOCH;
+    to->tv_sec = days * SECONDS_PER_DAY;
+    uint32_t msDay = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+			        + from[3];
+    from += 4;
+    to->tv_sec += (msDay / 1000);
+    to->tv_usec = (msDay % 1000) * 1000;
+    if ((pField & 0b11) == 0b01) {
+        uint16_t usecs = (from[0] << 16) + from[1];
+        from += 2;
+        if (usecs > 999) {
+            return INVALID_TIME_FORMAT;
+        }
+        to->tv_usec += usecs;
+    } else if ((pField & 0b11) == 0b10) {
+        uint32_t picosecs = (from[0] << 24) + (from[1] << 16) + (from[2] << 8)
+				        + from[3];
+        from += 4;
+        if (picosecs > 999999) {
+            return INVALID_TIME_FORMAT;
+        }
+        //Not very useful.
+        to->tv_usec += (picosecs / 1000);
+    }
+    return RETURN_OK;
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField,
-		const uint8_t* from, size_t* foundLength, size_t maxLength) {
-	uint32_t secs = 0;
-	uint32_t subSeconds = 0;
-	uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
-	uint8_t nFine = (pField & 0b11);
-	size_t totalLength = nCoarse + nFine;
-	if (foundLength != NULL) {
-		*foundLength = totalLength;
-	}
-	if (totalLength > maxLength) {
-		return LENGTH_MISMATCH;
-	}
-	for (int count = 0; count < nCoarse; count++) {
-		secs += *from << ((nCoarse * 8 - 8) * (1 + count));
-		from++;
-	}
-	for (int count = 0; count < nFine; count++) {
-		subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
-		from++;
-	}
-	//Move to POSIX epoch.
-	to->tv_sec = secs;
-	if (pField & 0b10000) {
-		//CCSDS-Epoch
-		to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
-	}
-	to->tv_usec = subsecondsToMicroseconds(subSeconds);
-	return RETURN_OK;
+        const uint8_t* from, size_t* foundLength, size_t maxLength) {
+    uint32_t secs = 0;
+    uint32_t subSeconds = 0;
+    uint8_t nCoarse = ((pField & 0b1100) >> 2) + 1;
+    uint8_t nFine = (pField & 0b11);
+    size_t totalLength = nCoarse + nFine;
+    if (foundLength != NULL) {
+        *foundLength = totalLength;
+    }
+    if (totalLength > maxLength) {
+        return LENGTH_MISMATCH;
+    }
+    for (int count = 0; count < nCoarse; count++) {
+        secs += *from << ((nCoarse * 8 - 8) * (1 + count));
+        from++;
+    }
+    for (int count = 0; count < nFine; count++) {
+        subSeconds += *from << ((nFine * 8 - 8) * (1 + count));
+        from++;
+    }
+    //Move to POSIX epoch.
+    to->tv_sec = secs;
+    if (pField & 0b10000) {
+        //CCSDS-Epoch
+        to->tv_sec -= (DAYS_CCSDS_TO_UNIX_EPOCH * SECONDS_PER_DAY);
+    }
+    to->tv_usec = subsecondsToMicroseconds(subSeconds);
+    return RETURN_OK;
 }
 
 uint32_t CCSDSTime::subsecondsToMicroseconds(uint16_t subseconds) {
-	uint64_t temp = (uint64_t) subseconds * 1000000
-			/ (1 << (sizeof(subseconds) * 8));
-	return temp;
+    uint64_t temp = (uint64_t) subseconds * 1000000
+            / (1 << (sizeof(subseconds) * 8));
+    return temp;
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(timeval* to, const uint8_t* from,
-		size_t* foundLength, size_t maxLength) {
-	Clock::TimeOfDay_t tempTime;
-	ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
-			maxLength);
-	if (result != RETURN_OK) {
-		return result;
-	}
+        size_t* foundLength, size_t maxLength) {
+    Clock::TimeOfDay_t tempTime;
+    ReturnValue_t result = convertFromCCS(&tempTime, from, foundLength,
+            maxLength);
+    if (result != RETURN_OK) {
+        return result;
+    }
 
-	return Clock::convertTimeOfDayToTimeval(&tempTime, to);
+    return Clock::convertTimeOfDayToTimeval(&tempTime, to);
 
 }
diff --git a/timemanager/CCSDSTime.h b/timemanager/CCSDSTime.h
index d74adc61..de151852 100644
--- a/timemanager/CCSDSTime.h
+++ b/timemanager/CCSDSTime.h
@@ -21,215 +21,215 @@ bool operator==(const timeval& lhs, const timeval& rhs);
  */
 class CCSDSTime: public HasReturnvaluesIF {
 public:
-	/**
-	 * The Time code identifications, bits 4-6 in the P-Field
-	 */
-	enum TimeCodeIdentification {
-		CCS = 0b101,
-		CUC_LEVEL1 = 0b001,
-		CUC_LEVEL2 = 0b010,
-		CDS = 0b100,
-		AGENCY_DEFINED = 0b110
-	};
-	static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
-			+ 2;
-	static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
-	/**
-	 * Struct for CDS day-segmented format.
-	 */
-	struct CDS_short {
-		uint8_t pField;
-		uint8_t dayMSB;
-		uint8_t dayLSB;
-		uint8_t msDay_hh;
-		uint8_t msDay_h;
-		uint8_t msDay_l;
-		uint8_t msDay_ll;
-	};
-	/**
-	 * Struct for the CCS fromat in day of month variation with max resolution
-	 */
-	struct Ccs_seconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-	};
+    /**
+     * The Time code identifications, bits 4-6 in the P-Field
+     */
+    enum TimeCodeIdentification {
+        CCS = 0b101,
+        CUC_LEVEL1 = 0b001,
+        CUC_LEVEL2 = 0b010,
+        CDS = 0b100,
+        AGENCY_DEFINED = 0b110
+    };
+    static const uint8_t P_FIELD_CUC_6B_CCSDS = (CUC_LEVEL1 << 4) + (3 << 2)
+			        + 2;
+    static const uint8_t P_FIELD_CUC_6B_AGENCY = (CUC_LEVEL2 << 4) + (3 << 2)
+			        + 2;
+    static const uint8_t P_FIELD_CDS_SHORT = (CDS << 4);
+    /**
+     * Struct for CDS day-segmented format.
+     */
+    struct CDS_short {
+        uint8_t pField;
+        uint8_t dayMSB;
+        uint8_t dayLSB;
+        uint8_t msDay_hh;
+        uint8_t msDay_h;
+        uint8_t msDay_l;
+        uint8_t msDay_ll;
+    };
+    /**
+     * Struct for the CCS fromat in day of month variation with max resolution
+     */
+    struct Ccs_seconds {
+        uint8_t pField;
+        uint8_t yearMSB;
+        uint8_t yearLSB;
+        uint8_t month;
+        uint8_t day;
+        uint8_t hour;
+        uint8_t minute;
+        uint8_t second;
+    };
 
-	/**
-	 * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
-	 */
-	struct Ccs_mseconds {
-		uint8_t pField;
-		uint8_t yearMSB;
-		uint8_t yearLSB;
-		uint8_t month;
-		uint8_t day;
-		uint8_t hour;
-		uint8_t minute;
-		uint8_t second;
-		uint8_t secondEminus2;
-		uint8_t secondEminus4;
-	};
+    /**
+     * Struct for the CCS fromat in day of month variation with 10E-4 seconds resolution
+     */
+    struct Ccs_mseconds {
+        uint8_t pField;
+        uint8_t yearMSB;
+        uint8_t yearLSB;
+        uint8_t month;
+        uint8_t day;
+        uint8_t hour;
+        uint8_t minute;
+        uint8_t second;
+        uint8_t secondEminus2;
+        uint8_t secondEminus4;
+    };
 
-	struct OBT_FLP {
-		uint8_t pFiled;
-		uint8_t seconds_hh;
-		uint8_t seconds_h;
-		uint8_t seconds_l;
-		uint8_t seconds_ll;
-		uint8_t subsecondsMSB;
-		uint8_t subsecondsLSB;
-	};
+    struct OBT_FLP {
+        uint8_t pFiled;
+        uint8_t seconds_hh;
+        uint8_t seconds_h;
+        uint8_t seconds_l;
+        uint8_t seconds_ll;
+        uint8_t subsecondsMSB;
+        uint8_t subsecondsLSB;
+    };
 
-	struct TimevalLess {
-		bool operator()(const timeval& lhs, const timeval& rhs) const {
-			return (lhs < rhs);
-		}
-	};
+    struct TimevalLess {
+        bool operator()(const timeval& lhs, const timeval& rhs) const {
+            return (lhs < rhs);
+        }
+    };
 
-	static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
-	static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
-	static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
-			MAKE_RETURN_CODE(1);
-	static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
-	static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
-	static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
-	static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
+    static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_TIME_HELPER_CLASS;
+    static const ReturnValue_t UNSUPPORTED_TIME_FORMAT = MAKE_RETURN_CODE(0);
+    static const ReturnValue_t NOT_ENOUGH_INFORMATION_FOR_TARGET_FORMAT =
+            MAKE_RETURN_CODE(1);
+    static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(2);
+    static const ReturnValue_t INVALID_TIME_FORMAT = MAKE_RETURN_CODE(3);
+    static const ReturnValue_t INVALID_DAY_OF_YEAR = MAKE_RETURN_CODE(4);
+    static const ReturnValue_t TIME_DOES_NOT_FIT_FORMAT = MAKE_RETURN_CODE(5);
 
-	/**
-	 * convert a TimeofDay struct to ccs with seconds resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_seconds *to,
-			Clock::TimeOfDay_t const *from);
+    /**
+     * convert a TimeofDay struct to ccs with seconds resolution
+     *
+     * @param to pointer to a CCS struct
+     * @param from pointer to a TimeOfDay Struct
+     * @return
+     * 		- @c RETURN_OK if OK
+     * 		- @c INVALID_TIMECODE if not OK
+     */
+    static ReturnValue_t convertToCcsds(Ccs_seconds *to,
+            Clock::TimeOfDay_t const *from);
 
-	/**
-	 * Converts to CDS format from timeval.
-	 * @param to pointer to the CDS struct to generate
-	 * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
-	 * @return
-	 * 		- @c RETURN_OK as it assumes a valid timeval.
-	 */
-	static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
+    /**
+     * Converts to CDS format from timeval.
+     * @param to pointer to the CDS struct to generate
+     * @param from pointer to a timeval struct which comprises a time of day since UNIX epoch.
+     * @return
+     * 		- @c RETURN_OK as it assumes a valid timeval.
+     */
+    static ReturnValue_t convertToCcsds(CDS_short* to, timeval const *from);
 
-	static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
+    static ReturnValue_t convertToCcsds(OBT_FLP* to, timeval const *from);
 
-	/**
-	 * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
-	 *
-	 * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
-	 *
-	 * @param to pointer to a CCS struct
-	 * @param from pointer to a TimeOfDay Struct
-	 * @return
-	 * 		- @c RETURN_OK if OK
-	 * 		- @c INVALID_TIMECODE if not OK
-	 */
-	static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
-			Clock::TimeOfDay_t const *from);
+    /**
+     * convert a TimeofDay struct to ccs with 10E-3 seconds resolution
+     *
+     * The 10E-4 seconds in the CCS Struct are 0 as the TimeOfDay only has ms resolution
+     *
+     * @param to pointer to a CCS struct
+     * @param from pointer to a TimeOfDay Struct
+     * @return
+     * 		- @c RETURN_OK if OK
+     * 		- @c INVALID_TIMECODE if not OK
+     */
+    static ReturnValue_t convertToCcsds(Ccs_mseconds *to,
+            Clock::TimeOfDay_t const *from);
 
-	/**
-	 * SHOULDDO: can this be modified to recognize padding?
-	 * Tries to interpret a Level 1 CCSDS time code
-	 *
-	 * It assumes binary formats contain a valid P Field and recognizes the ASCII format
-	 * by the lack of one.
-	 *
-	 * @param to an empty TimeOfDay struct
-	 * @param from pointer to an CCSDS Time code
-	 * @param length length of the Time code
-	 * @return
-	 * 		- @c RETURN_OK if successful
-	 * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
-	 * 		- @c LENGTH_MISMATCH if the length does not match the P Field
-	 * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
-	 */
-	static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, size_t length);
+    /**
+     * SHOULDDO: can this be modified to recognize padding?
+     * Tries to interpret a Level 1 CCSDS time code
+     *
+     * It assumes binary formats contain a valid P Field and recognizes the ASCII format
+     * by the lack of one.
+     *
+     * @param to an empty TimeOfDay struct
+     * @param from pointer to an CCSDS Time code
+     * @param length length of the Time code
+     * @return
+     * 		- @c RETURN_OK if successful
+     * 		- @c UNSUPPORTED_TIME_FORMAT if a (possibly valid) time code is not supported
+     * 		- @c LENGTH_MISMATCH if the length does not match the P Field
+     * 		- @c INVALID_TIME_FORMAT if the format or a value is invalid
+     */
+    static ReturnValue_t convertFromCcsds(Clock::TimeOfDay_t *to,
+            uint8_t const *from, size_t length);
 
-	/**
-	 * not implemented yet
-	 *
-	 * @param to
-	 * @param from
-	 * @return
-	 */
-	static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    /**
+     * not implemented yet
+     *
+     * @param to
+     * @param from
+     * @return
+     */
+    static ReturnValue_t convertFromCcsds(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromCUC(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCUC(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
-			uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCUC(timeval *to, uint8_t pField,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
-			uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(timeval *to, uint8_t pField,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromCDS(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
-			size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCDS(timeval *to, uint8_t const *from,
+            size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, size_t* foundLength, size_t maxLength);
+    static ReturnValue_t convertFromCCS(Clock::TimeOfDay_t *to,
+            uint8_t const *from, size_t* foundLength, size_t maxLength);
 
-	static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
-	        uint8_t const *from, uint8_t length);
+    static ReturnValue_t convertFromASCII(Clock::TimeOfDay_t *to,
+            uint8_t const *from, uint8_t length);
 
-	static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
+    static uint32_t subsecondsToMicroseconds(uint16_t subseconds);
 private:
-	CCSDSTime();
-	virtual ~CCSDSTime();
-	/**
-	 * checks a ccs time stream for validity
-	 *
-	 * Stream may be longer than the actual timecode
-	 *
-	 * @param time pointer to an Ccs stream
-	 * @param length length of stream
-	 * @return
-	 */
-	static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
+    CCSDSTime();
+    virtual ~CCSDSTime();
+    /**
+     * checks a ccs time stream for validity
+     *
+     * Stream may be longer than the actual timecode
+     *
+     * @param time pointer to an Ccs stream
+     * @param length length of stream
+     * @return
+     */
+    static ReturnValue_t checkCcs(const uint8_t* time, uint8_t length);
 
-	static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
+    static ReturnValue_t checkTimeOfDay(const Clock::TimeOfDay_t *time);
 
-	static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
-	static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
-	static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
-	static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
-			* SECONDS_PER_DAY;
-	/**
-	 * @param dayofYear
-	 * @param year
-	 * @param month
-	 * @param day
-	 */
-	static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
-			uint8_t *month, uint8_t *day);
+    static const uint32_t SECONDS_PER_DAY = 24 * 60 * 60;
+    static const uint32_t SECONDS_PER_NON_LEAP_YEAR = SECONDS_PER_DAY * 365;
+    static const uint32_t DAYS_CCSDS_TO_UNIX_EPOCH = 4383; //!< Time difference between CCSDS and POSIX epoch. This is exact, because leap-seconds where not introduced before 1972.
+    static const uint32_t SECONDS_CCSDS_TO_UNIX_EPOCH = DAYS_CCSDS_TO_UNIX_EPOCH
+            * SECONDS_PER_DAY;
+    /**
+     * @param dayofYear
+     * @param year
+     * @param month
+     * @param day
+     */
+    static ReturnValue_t convertDaysOfYear(uint16_t dayofYear, uint16_t year,
+            uint8_t *month, uint8_t *day);
 
-	static bool isLeapYear(uint32_t year);
-	static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
-			timeval* from);
+    static bool isLeapYear(uint32_t year);
+    static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to,
+            timeval* from);
 };
 
 #endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */

From 4250c7e022ede038d756d4a88e7b206377d93d3d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:45:35 +0100
Subject: [PATCH 08/21] updated changelog

---
 CHANGELOG | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index fc46ee02..bd41de5a 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -82,6 +82,10 @@ now
   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
+
+- ActionHelper finish function 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).
\ No newline at end of file
+Added PUS parameter service 20 (only custom subservices available).

From bd903b844776f80718ad74d6132c74046aae7607 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:46:39 +0100
Subject: [PATCH 09/21] changelog update

---
 CHANGELOG | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index bd41de5a..235ed7d3 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -22,7 +22,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 +42,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 +55,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 +73,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
 
@@ -82,9 +87,11 @@ now
   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
+### ActionHelper and ActionMessage
 
-- ActionHelper finish function now expects explicit information whether to report a success or failure message instead of deriving it implicitely from returnvalue
+- 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
 

From 043d47e5e43348a79fc50a7550ddcc0caeab2dba Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 16:48:21 +0100
Subject: [PATCH 10/21] removing whitespaces

---
 CHANGELOG | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index 235ed7d3..add8e1a5 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -22,8 +22,8 @@ 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 
+- 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
@@ -42,7 +42,7 @@ important use-case)
    
 ### File System Interface
 
-- A new interfaces specifies the functions for a software object which exposes the file system of 
+- 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

From 35825a6561379506e092a02266efe833743fc862 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:27:03 +0100
Subject: [PATCH 11/21] new functions to set all vars read only

---
 datapool/PoolVariableIF.h              |  3 ++-
 datapoollocal/LocalPoolDataSetBase.cpp |  7 ++++++-
 datapoollocal/LocalPoolDataSetBase.h   |  6 ++++++
 doc/README-localpools.md               | 26 ++++++++++++++++++++++++++
 4 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/datapool/PoolVariableIF.h b/datapool/PoolVariableIF.h
index dead6844..dbb9db15 100644
--- a/datapool/PoolVariableIF.h
+++ b/datapool/PoolVariableIF.h
@@ -46,6 +46,8 @@ public:
      * 			read-write or read-only.
      */
     virtual ReadWriteMode_t getReadWriteMode() const = 0;
+    virtual void setReadWriteMode(ReadWriteMode_t newMode) = 0;
+
     /**
      * @brief	This operation shall return the data pool id of the variable.
      */
@@ -59,7 +61,6 @@ public:
      * @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;
diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp
index d043d18f..daa54fb3 100644
--- a/datapoollocal/LocalPoolDataSetBase.cpp
+++ b/datapoollocal/LocalPoolDataSetBase.cpp
@@ -288,7 +288,7 @@ bool LocalPoolDataSetBase::isValid() const {
 void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
     if(setEntriesRecursively) {
         for(size_t idx = 0; idx < this->getFillCount(); idx++) {
-            registeredVariables[idx] -> setValid(valid);
+            registeredVariables[idx]->setValid(valid);
         }
     }
     this->valid = valid;
@@ -301,3 +301,8 @@ object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
     return objects::NO_OBJECT;
 }
 
+void LocalPoolDataSetBase::setAllVariablesReadOnly() {
+    for(size_t idx = 0; idx < this->getFillCount(); idx++) {
+        registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
+    }
+}
diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h
index 9501f782..404509ae 100644
--- a/datapoollocal/LocalPoolDataSetBase.h
+++ b/datapoollocal/LocalPoolDataSetBase.h
@@ -109,6 +109,12 @@ public:
     LocalPoolDataSetBase(const LocalPoolDataSetBase& otherSet) = delete;
     const LocalPoolDataSetBase& operator=(const LocalPoolDataSetBase& otherSet) = delete;
 
+    /**
+     * Helper functions used to set all currently contained variables to read-only.
+     * It is recommended to call this in set constructors intended to be used
+     * by data consumers to prevent accidentally changing pool data.
+     */
+    void setAllVariablesReadOnly();
     void setValidityBufferGeneration(bool withValidityBuffer);
 
     sid_t getSid() const;
diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 8dd83385..57a41aa1 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,3 +1,29 @@
 ## Local Data Pools
 
+The local data pools can be used to store data like sensor values so they can be used 
+by other software objects like controllers as well. If a 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 class
+2. Implement the `HasLocalDataPoolIF`
+
+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.
+Two important framework classes 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 is done via proxy classes like pool variable classes or dataset classes.
+Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
+
+The user can then use this set class to `read` the variables and `commit` changed variables
+back into the pool.
+
+### Using the local data pools of the `DeviceHandlerBase`
+
+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. The

From 8de33f13014f059f53767968eb11f8fe8a1ad32d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:46:42 +0100
Subject: [PATCH 12/21] added local pool doc

---
 doc/README-localpools.md | 134 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 130 insertions(+), 4 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 57a41aa1..9e7ddeac 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,4 +1,4 @@
-## Local Data Pools
+## Local Data Pools Developer Information
 
 The local data pools can be used to store data like sensor values so they can be used 
 by other software objects like controllers as well. If a class should have a local pool which
@@ -20,10 +20,136 @@ access to the pool data is done via proxy classes like pool variable classes or
 Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
 
 The user can then use this set class to `read` the variables and `commit` changed variables
-back into the pool.
+back into the pool. The general approach is that a user will create a header containing the set
+class. For example, the following code shows an implementation to access data from a Gyroscope:
 
-### Using the local data pools of the `DeviceHandlerBase`
+```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 constructor for users which sets all variables to read-only and there is the constructor
+for the GyroHandler data creator. 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. The
+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 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, we have received 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;
+}
+```
+
+### Using the local data pools in a `ExtendedControllerBase` subclass
+
+Coming soon
+
+

From 23873f6bc60cdef68e022e6bfd9d2ddd65b1723e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 17:58:07 +0100
Subject: [PATCH 13/21] improved readme

---
 doc/README-localpools.md | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 9e7ddeac..399400a4 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,27 +1,37 @@
 ## Local Data Pools Developer Information
 
 The local data pools can be used to store data like sensor values so they can be used 
-by other software objects like controllers as well. If a class should have a local pool which
+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 class
-2. Implement the `HasLocalDataPoolIF`
+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.
-Two important framework classes already perform the two steps shown above so the steps required
-are altered slightly. 
+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 is done via proxy classes like pool variable classes or dataset classes.
-Generally, a user will create a dataset class which in turn groups all cohesive pool variables.
+access to the pool data from the point of a mission software developer is given in form of
+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 user can then use this set class to `read` the variables and `commit` changed variables
-back into the pool. The general approach is that a user will create a header containing the set
-class. For example, the following code shows an implementation to access data from a Gyroscope:
+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)> {
@@ -53,8 +63,9 @@ private:
 };
 ```
 
-There is a constructor for users which sets all variables to read-only and there is the constructor
-for the GyroHandler data creator. Both the atittude controller and the `GyroHandler` can now
+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 makring 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
@@ -148,6 +159,8 @@ if(readHelper.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
 }
 ```
 
+The guard class will commit the changed data on destruction automatically.
+
 ### Using the local data pools in a `ExtendedControllerBase` subclass
 
 Coming soon

From a7878aaf0446b85a71da8522a7e3f6807407cbe1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:06:11 +0100
Subject: [PATCH 14/21] readme update

---
 doc/README-localpools.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 399400a4..223b9d2b 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -103,8 +103,8 @@ GyroHandler::GyroHandler(object_id_t objectId, object_id_t comIF,
 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 in some way so that the local pool manager
-can access the custom data sets as well.
+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,

From d84003d62a08ddc722e0363bf4cfe381d3f44785 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:07:10 +0100
Subject: [PATCH 15/21] updated READMe

---
 doc/README-localpools.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 223b9d2b..8b1fc45b 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -142,7 +142,7 @@ ReturnValue_t GyroHandler::initializeLocalDataPool(localpool::DataPool &localDat
 }
 ```
 
-Now, we have received some sensor data and converted them into the right format, 
+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:
 

From 6df1abf570e57e134e46c50d1b8aeff2f6f6404d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:11:10 +0100
Subject: [PATCH 16/21] added graph

---
 doc/README-localpools.md        |   6 +++++-
 doc/images/PoolArchitecture.png | Bin 0 -> 53460 bytes
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 doc/images/PoolArchitecture.png

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 8b1fc45b..04116797 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -15,7 +15,11 @@ The two former tasks are related to the external interface using telemetry and t
 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. 
+shown above so the steps required are altered slightly. The following diagram shows the
+high-level architecture of the local data pools.
+
+<img align="center" src="./images/PoolArchitecture.png" width="50%">
+
 
 ### Storing and Accessing pool data 
 
diff --git a/doc/images/PoolArchitecture.png b/doc/images/PoolArchitecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..13ea85c8886ee64629152d6ea4a2b3e58f7085be
GIT binary patch
literal 53460
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
A;s5{u

literal 0
HcmV?d00001


From 69b428222ac26611acbf9ef8938516de0c0e6884 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:12:34 +0100
Subject: [PATCH 17/21] updated readme

---
 doc/README-localpools.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 04116797..2f9bba7f 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -15,11 +15,7 @@ The two former tasks are related to the external interface using telemetry and t
 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. The following diagram shows the
-high-level architecture of the local data pools.
-
-<img align="center" src="./images/PoolArchitecture.png" width="50%">
-
+shown above so the steps required are altered slightly.
 
 ### Storing and Accessing pool data 
 
@@ -31,7 +27,10 @@ on a `read` call. Changed variables can then be written to the local pool with a
 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.
+`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 e0d7363eed3bac2e2d1535be77c1b8f6e94025cc Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:14:29 +0100
Subject: [PATCH 18/21] better entry text

---
 doc/README-localpools.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 2f9bba7f..548fa272 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -1,8 +1,9 @@
 ## Local Data Pools Developer Information
 
-The local data pools can be used 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:
+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
@@ -67,7 +68,7 @@ private:
 ```
 
 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 makring it private and declaring the `GyroHandler`
+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

From e501390d7be09ece647d829b63b81e2bc2dc6277 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:20:58 +0100
Subject: [PATCH 19/21] readme typo

---
 doc/README-localpools.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 548fa272..4ac2a4d8 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -21,7 +21,7 @@ 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 a mission software developer is given in form of
+access to the pool data from the point of view of a mission software developer is in form of
 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.

From a56cf4389754b577b86ca14d47a5dc7bf97ff2d1 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:22:32 +0100
Subject: [PATCH 20/21] another rwadme update

---
 doc/README-localpools.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/README-localpools.md b/doc/README-localpools.md
index 4ac2a4d8..96ae2d0a 100644
--- a/doc/README-localpools.md
+++ b/doc/README-localpools.md
@@ -21,8 +21,8 @@ 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 is in form of
-proxy classes like pool variable classes. These classes store a copy
+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

From 227074fd4d165a8433d55a4baeac18b5ef84d6da Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Mar 2021 18:45:32 +0100
Subject: [PATCH 21/21] increaed exception safety

---
 datapoollocal/LocalPoolObjectBase.cpp | 13 +++++++++----
 datapoollocal/LocalPoolVariable.tpp   | 26 ++++++++++++++++++++++----
 2 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/datapoollocal/LocalPoolObjectBase.cpp b/datapoollocal/LocalPoolObjectBase.cpp
index a64ed2b4..b6db0608 100644
--- a/datapoollocal/LocalPoolObjectBase.cpp
+++ b/datapoollocal/LocalPoolObjectBase.cpp
@@ -37,15 +37,20 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
     if(poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
-                << "which is the NO_PARAMETER value!" << std::endl;
+                "which is the NO_PARAMETER value!" << std::endl;
+#else
+        sif::printWarning("LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
+                "which is the NO_PARAMETER value!\n");
 #endif
     }
     HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "LocalPoolVariable: The supplied pool owner did not "
-                << "implement the correct interface"
-                << " HasLocalDataPoolIF!" << std::endl;
+        sif::error << "LocalPoolVariable: The supplied pool owner did not implement the correct "
+                "interface HasLocalDataPoolIF!" << std::endl;
+#else
+        sif::printError( "LocalPoolVariable: The supplied pool owner did not implement the correct "
+                "interface HasLocalDataPoolIF!\n");
 #endif
         return;
     }
diff --git a/datapoollocal/LocalPoolVariable.tpp b/datapoollocal/LocalPoolVariable.tpp
index aa789a6d..ba7a413d 100644
--- a/datapoollocal/LocalPoolVariable.tpp
+++ b/datapoollocal/LocalPoolVariable.tpp
@@ -26,8 +26,17 @@ inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::read(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return readWithoutLock();
+    if(hkManager == nullptr) {
+        return readWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = readWithoutLock();
+    mutex->unlockMutex();
+    return result;
 }
 
 template<typename T>
@@ -65,8 +74,17 @@ inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid,
 template<typename T>
 inline ReturnValue_t LocalPoolVariable<T>::commit(
         MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-    MutexHelper(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-    return commitWithoutLock();
+    if(hkManager == nullptr) {
+        return commitWithoutLock();
+    }
+    MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
+    ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    result = commitWithoutLock();
+    mutex->unlockMutex();
+    return result;
 }
 
 template<typename T>