From e5cea3ead078302df24d17ce43895ceae5c5046c Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 29 May 2020 20:31:08 +0200
Subject: [PATCH 01/28] service interface stream enhancements

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 28 +++++++++++++--------
 serviceinterface/ServiceInterfaceBuffer.h   | 28 ++++++++++++++++-----
 serviceinterface/ServiceInterfaceStream.cpp |  6 ++---
 serviceinterface/ServiceInterfaceStream.h   |  7 +++---
 4 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 58065994..2a97ab90 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -23,14 +23,16 @@ int ServiceInterfaceBuffer::sync(void) {
 	if (this->isActive) {
 		Clock::TimeOfDay_t loggerTime;
 		Clock::getDateAndTime(&loggerTime);
-		char preamble[96] = { 0 };
-		sprintf(preamble, "%s: | %lu:%02lu:%02lu.%03lu | ",
-				this->log_message.c_str(), (unsigned long) loggerTime.hour,
-				(unsigned long) loggerTime.minute,
-				(unsigned long) loggerTime.second,
-				(unsigned long) loggerTime.usecond /1000);
+		std::string preamble;
+		if(addCrToPreamble) {
+			preamble += "\r";
+		}
+		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
+				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+				+ zero_padded(loggerTime.second, 2) + "."
+				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 		// Write log_message and time
-		this->putChars(preamble, preamble + sizeof(preamble));
+		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
 		// Handle output
 		this->putChars(pbase(), pptr());
 	}
@@ -39,9 +41,13 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+
+
 #ifndef UT699
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+        uint16_t port, bool addCrToPreamble) {
+	this->addCrToPreamble = addCrToPreamble;
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
@@ -55,17 +61,19 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	}
 	memcpy(array, begin, length);
 
-	for( ; begin != end; begin++){
+	for(; begin != end; begin++){
 		printChar(begin);
 	}
 
 }
 #endif
 
+
 #ifdef UT699
 #include <framework/osal/rtems/Interrupt.h>
 
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
+		uint16_t port) {
 	this->log_message = set_message;
 	this->isActive = true;
 	setp( buf, buf + BUF_SIZE );
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index b42c8a19..a2bc4f4b 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -2,32 +2,36 @@
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
 #include <iostream>
-#include <iosfwd>
 #include <sstream>
 #include <cstdio>
+#include <iomanip>
 
 #ifndef UT699
-class ServiceInterfaceBuffer: public std::basic_streambuf<char,
-		std::char_traits<char> > {
+class ServiceInterfaceBuffer:
+        public std::basic_streambuf<char,std::char_traits<char>> {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
+			bool addCrToPreamble);
 protected:
 	bool isActive;
 	// This is called when buffer becomes full. If
 	// buffer is not used, then this is called every
 	// time when characters are put to stream.
-	virtual int overflow(int c = Traits::eof());
+	int overflow(int c = Traits::eof()) override;
 
 	// This function is called when stream is flushed,
 	// for example when std::endl is put to stream.
-	virtual int sync(void);
+	int sync(void) override;
 
 private:
 	// For additional message information
 	std::string log_message;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+	// This is useful for some terminal programs which do not have
+	// implicit carriage return with newline characters.
+	bool addCrToPreamble;
 
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
@@ -35,6 +39,18 @@ private:
 
 	// In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
+
+	template<typename T>
+	std::string zero_padded(const T& num, uint8_t width) {
+	    std::ostringstream string_to_pad;
+	    string_to_pad << std::setw(width) << std::setfill('0') << num;
+	    std::string result = string_to_pad.str();
+	    if (result.length() > width)
+	    {
+	        result.erase(0, result.length() - width);
+	    }
+	    return result;
+	}
 };
 #endif
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index c2979f36..40f52f1f 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -5,7 +5,7 @@ void ServiceInterfaceStream::setActive( bool myActive) {
 }
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char> >(&buf), buf(
-				set_message, port) {
+		bool addCrToPreamble, uint16_t port) :
+		std::basic_ostream<char, std::char_traits<char>>(&buf),
+		buf(set_message, port, addCrToPreamble) {
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index df736a1b..a445dced 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -17,14 +17,15 @@ extern std::ostream error;
 }
 
 
-class ServiceInterfaceStream : public std::basic_ostream< char, std::char_traits< char > > {
+class ServiceInterfaceStream :
+        public std::basic_ostream<char, std::char_traits<char>> {
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message, uint16_t port = 1234 );
+    ServiceInterfaceStream( std::string set_message,
+    		bool addCrToPreamble = false, uint16_t port = 1234);
 	void setActive( bool );
 };
 
 
-
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 7259a1356959ab9fb18472bfdeb45a2c88f864dd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:14:17 +0200
Subject: [PATCH 02/28] more improvements:

1. New optional flag to redirect print to stderr. THis can be useful on
host environemtns (e.g linux)
2. non-buffered mode if this flag is true: the preamble msut be printed
manually
2. Getter function for preamble for that case.
3. printChar function: specify whether to print to stderr or stdout
---
 serviceinterface/ServiceInterfaceBuffer.cpp | 94 ++++++++++++---------
 serviceinterface/ServiceInterfaceBuffer.h   | 50 ++++++++---
 serviceinterface/ServiceInterfaceStream.cpp | 12 ++-
 serviceinterface/ServiceInterfaceStream.h   | 37 ++++++--
 4 files changed, 131 insertions(+), 62 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 2a97ab90..93de88b3 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -3,9 +3,42 @@
 #include <cstring>
 
 // to be implemented by bsp
-extern "C" void printChar(const char*);
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
+        bool errStream, bool addCrToPreamble, uint16_t port):
+		isActive(true), logMessage(setMessage),
+		addCrToPreamble(addCrToPreamble), errStream(errStream) {
+	if(not errStream) {
+		// Set pointers if the stream is buffered.
+		setp( buf, buf + BUF_SIZE );
+	}
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+	char array[BUF_SIZE];
+	uint32_t length = end - begin;
+	if (length > sizeof(array)) {
+		length = sizeof(array);
+	}
+	memcpy(array, begin, length);
+
+	for(; begin != end; begin++){
+		printChar(begin, false);
+	}
+}
+
+#endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
+	if(errStream and this->isActive) {
+		if (c != Traits::eof()) {
+			printChar(reinterpret_cast<const char*>(&c), true);
+		}
+		return 0;
+	}
 	// Handle output
 	putChars(pbase(), pptr());
 	if (c != Traits::eof()) {
@@ -20,53 +53,38 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if (this->isActive) {
-		Clock::TimeOfDay_t loggerTime;
-		Clock::getDateAndTime(&loggerTime);
-		std::string preamble;
-		if(addCrToPreamble) {
-			preamble += "\r";
+	if(not this->isActive or errStream) {
+		if(not errStream) {
+			setp(buf, buf + BUF_SIZE - 1);
 		}
-		preamble += log_message + ": | " + zero_padded(loggerTime.hour, 2)
-				+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-				+ zero_padded(loggerTime.second, 2) + "."
-				+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
-		// Write log_message and time
-		this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
-		// Handle output
-		this->putChars(pbase(), pptr());
+		return 0;
 	}
+
+	auto preamble = getPreamble();
+	// Write logMessage and time
+	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	// Handle output
+	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
 	setp(buf, buf + BUF_SIZE - 1);
 	return 0;
 }
 
 
-
-#ifndef UT699
-
-ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message,
-        uint16_t port, bool addCrToPreamble) {
-	this->addCrToPreamble = addCrToPreamble;
-	this->log_message = set_message;
-	this->isActive = true;
-	setp( buf, buf + BUF_SIZE );
+std::string ServiceInterfaceBuffer::getPreamble() {
+	Clock::TimeOfDay_t loggerTime;
+	Clock::getDateAndTime(&loggerTime);
+	std::string preamble;
+	if(addCrToPreamble) {
+		preamble += "\r";
+	}
+	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
+							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+							+ zero_padded(loggerTime.second, 2) + "."
+							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+	return preamble;
 }
 
-void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
-	char array[BUF_SIZE];
-	uint32_t length = end - begin;
-	if (length > sizeof(array)) {
-		length = sizeof(array);
-	}
-	memcpy(array, begin, length);
-
-	for(; begin != end; begin++){
-		printChar(begin);
-	}
-
-}
-#endif
 
 
 #ifdef UT699
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a2bc4f4b..74facafe 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -3,43 +3,64 @@
 
 #include <iostream>
 #include <sstream>
-#include <cstdio>
 #include <iomanip>
 
 #ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
 class ServiceInterfaceBuffer:
-        public std::basic_streambuf<char,std::char_traits<char>> {
+        public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string set_message, uint16_t port,
-			bool addCrToPreamble);
+	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
+			bool addCrToPreamble, uint16_t port);
+
 protected:
 	bool isActive;
-	// This is called when buffer becomes full. If
-	// buffer is not used, then this is called every
-	// time when characters are put to stream.
+	//! This is called when buffer becomes full. If
+	//! buffer is not used, then this is called every
+	//! time when characters are put to stream.
 	int overflow(int c = Traits::eof()) override;
 
-	// This function is called when stream is flushed,
-	// for example when std::endl is put to stream.
+	//! This function is called when stream is flushed,
+	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
 private:
-	// For additional message information
-	std::string log_message;
+	//! For additional message information
+	std::string logMessage;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
-	// This is useful for some terminal programs which do not have
-	// implicit carriage return with newline characters.
+	//! This is useful for some terminal programs which do not have
+	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	//! This specifies to print to stderr and work in unbuffered mode.
+	bool errStream;
 
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 
-	// In this function, the characters are parsed.
+	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
+	std::string getPreamble();
+
+	/**
+	 * This helper function returns the zero padded string version of a number.
+	 * The type is deduced automatically.
+	 * @tparam T
+	 * @param num
+	 * @param width
+	 * @return
+	 */
 	template<typename T>
 	std::string zero_padded(const T& num, uint8_t width) {
 	    std::ostringstream string_to_pad;
@@ -52,6 +73,7 @@ private:
 	    return result;
 	}
 };
+
 #endif
 
 
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 40f52f1f..78371548 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,11 +1,15 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
+		bool errStream, bool addCrToPreamble, uint16_t port) :
+		std::ostream(&buf),
+		buf(setMessage, errStream, addCrToPreamble, port) {
+}
+
 void ServiceInterfaceStream::setActive( bool myActive) {
 	this->buf.isActive = myActive;
 }
 
-ServiceInterfaceStream::ServiceInterfaceStream(std::string set_message,
-		bool addCrToPreamble, uint16_t port) :
-		std::basic_ostream<char, std::char_traits<char>>(&buf),
-		buf(set_message, port, addCrToPreamble) {
+std::string ServiceInterfaceStream::getPreamble() {
+	return buf.getPreamble();
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index a445dced..aecd45c3 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -3,11 +3,9 @@
 
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <iostream>
-#include <iosfwd>
-#include <sstream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of log_fe
+// Unfortunately, there must be a forward declaration of the log front end
 // (MUST be defined in main), to let the system know where to write to.
 namespace sif {
 extern std::ostream debug;
@@ -18,14 +16,41 @@ extern std::ostream error;
 
 
 class ServiceInterfaceStream :
-        public std::basic_ostream<char, std::char_traits<char>> {
+        public std::ostream {
 protected:
     ServiceInterfaceBuffer buf;
 public:
-    ServiceInterfaceStream( std::string set_message,
-    		bool addCrToPreamble = false, uint16_t port = 1234);
+    /**
+     * This constructor is used by specifying the preamble message.
+     * Optionally, the output can be directed to stderr and a CR character
+     * can be prepended to the preamble.
+     * @param set_message
+     * @param errStream
+     * @param addCrToPreamble
+     * @param port
+     */
+    ServiceInterfaceStream(std::string setMessage,
+    		bool errStream = false, bool addCrToPreamble = false,
+			uint16_t port = 1234);
+
+    //! An inactive stream will not print anything.
 	void setActive( bool );
+
+	/**
+	 * This can be used to retrieve the preamble in case it should be printed in
+	 * the unbuffered mode.
+	 * @return Preamle consisting of log message and timestamp.
+	 */
+	std::string getPreamble();
 };
 
+// Forward declaration of interface streams. These are needed so the public
+// functions can be used by including this header
+namespace sif {
+extern ServiceInterfaceStream debugStream;
+extern ServiceInterfaceStream infoStream;
+extern ServiceInterfaceStream warningStream;
+extern ServiceInterfaceStream errorStream;
+}
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 9361568b4513645fb42a571659e8e060b3d374c7 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 3 Jun 2020 23:28:31 +0200
Subject: [PATCH 03/28] clarifying commnet

---
 serviceinterface/ServiceInterfaceStream.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index aecd45c3..375a1875 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,8 +5,11 @@
 #include <iostream>
 #include <cstdio>
 
-// Unfortunately, there must be a forward declaration of the log front end
-// (MUST be defined in main), to let the system know where to write to.
+/* Unfortunately, there must be a forward declaration of the log front end
+ * (MUST be defined in main), to let the system know where to write to.
+ * The ServiceInterfaceStream instances, which are declared below and
+ * can instantaited somewhere else can be passed to these front ends by passing
+ * their underlying buffers with .rdbuf() */
 namespace sif {
 extern std::ostream debug;
 extern std::ostream info;

From 764608005b0934c02faedf9913ae7b3153e11ba3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 13:26:35 +0200
Subject: [PATCH 04/28] buf renamed to streambuf

---
 osal/FreeRTOS/MessageQueue.cpp              | 3 ++-
 serviceinterface/ServiceInterfaceStream.cpp | 8 ++++----
 serviceinterface/ServiceInterfaceStream.h   | 2 +-
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/osal/FreeRTOS/MessageQueue.cpp b/osal/FreeRTOS/MessageQueue.cpp
index e5da0442..18e7aa3d 100644
--- a/osal/FreeRTOS/MessageQueue.cpp
+++ b/osal/FreeRTOS/MessageQueue.cpp
@@ -97,7 +97,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		bool ignoreFault) {
 	message->setSender(sentFrom);
 
-	BaseType_t result = xQueueSendToBack(reinterpret_cast<void*>(sendTo),reinterpret_cast<const void*>(message->getBuffer()), 0);
+	BaseType_t result = xQueueSendToBack(reinterpret_cast<QueueHandle_t>(sendTo),
+			reinterpret_cast<const void*>(message->getBuffer()), 0);
 	if (result != pdPASS) {
 		if (!ignoreFault) {
 			InternalErrorReporterIF* internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index 78371548..d9bc980a 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -2,14 +2,14 @@
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool errStream, bool addCrToPreamble, uint16_t port) :
-		std::ostream(&buf),
-		buf(setMessage, errStream, addCrToPreamble, port) {
+		std::ostream(&streambuf),
+		streambuf(setMessage, errStream, addCrToPreamble, port) {
 }
 
 void ServiceInterfaceStream::setActive( bool myActive) {
-	this->buf.isActive = myActive;
+	this->streambuf.isActive = myActive;
 }
 
 std::string ServiceInterfaceStream::getPreamble() {
-	return buf.getPreamble();
+	return streambuf.getPreamble();
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 375a1875..c44fe03a 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -21,7 +21,7 @@ extern std::ostream error;
 class ServiceInterfaceStream :
         public std::ostream {
 protected:
-    ServiceInterfaceBuffer buf;
+    ServiceInterfaceBuffer streambuf;
 public:
     /**
      * This constructor is used by specifying the preamble message.

From f8fb370ae7698c8b27c86428ab01129042cedfa3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 14:08:26 +0200
Subject: [PATCH 05/28] preamble changes started

---
 osal/FreeRTOS/FixedTimeslotTask.cpp         |  2 +-
 serviceinterface/ServiceInterfaceBuffer.cpp | 65 +++++++++++++++------
 serviceinterface/ServiceInterfaceBuffer.h   |  8 ++-
 serviceinterface/ServiceInterfaceStream.cpp | 28 +++++++--
 serviceinterface/ServiceInterfaceStream.h   | 53 ++++++++---------
 5 files changed, 104 insertions(+), 52 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index fb3c3b03..549ffbf1 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -68,7 +68,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	}
 
 	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst" << std::endl;
+			" not found, not adding it to pst\r" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 93de88b3..321b1d3c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -8,13 +8,15 @@ extern "C" void printChar(const char*, bool errStream);
 #ifndef UT699
 
 ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
-        bool errStream, bool addCrToPreamble, uint16_t port):
+		bool addCrToPreamble, bool buffered , bool errStream, uint16_t port):
 		isActive(true), logMessage(setMessage),
-		addCrToPreamble(addCrToPreamble), errStream(errStream) {
-	if(not errStream) {
+		addCrToPreamble(addCrToPreamble), buffered(buffered),
+		errStream(errStream) {
+	if(buffered) {
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
+	preamble.reserve(96);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -26,16 +28,27 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 	memcpy(array, begin, length);
 
 	for(; begin != end; begin++){
-		printChar(begin, false);
+		if(errStream) {
+			printChar(begin, true);
+		}
+		else {
+			printChar(begin, false);
+		}
+
 	}
 }
 
 #endif
 
 int ServiceInterfaceBuffer::overflow(int c) {
-	if(errStream and this->isActive) {
+	if(not buffered and this->isActive) {
 		if (c != Traits::eof()) {
-			printChar(reinterpret_cast<const char*>(&c), true);
+			if(errStream) {
+				printChar(reinterpret_cast<const char*>(&c), true);
+			}
+			else {
+				printChar(reinterpret_cast<const char*>(&c), false);
+			}
 		}
 		return 0;
 	}
@@ -53,16 +66,17 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive or errStream) {
-		if(not errStream) {
+	if(not this->isActive) {
+		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
 	}
 
-	auto preamble = getPreamble();
+	size_t preambleSize  = 0;
+	auto preamble = getPreamble(&preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.c_str(), preamble.c_str() + preamble.size());
+	this->putChars(preamble.c_str(), preamble.c_str() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -71,17 +85,34 @@ int ServiceInterfaceBuffer::sync(void) {
 }
 
 
-std::string ServiceInterfaceBuffer::getPreamble() {
+std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble;
+	//preamble.clear();
+	//std::string preamble;
+	size_t currentSize = 0;
 	if(addCrToPreamble) {
-		preamble += "\r";
+		preamble[0] = '\r';
+		currentSize += 1;
 	}
-	preamble += logMessage + ": | " + zero_padded(loggerTime.hour, 2)
-							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-							+ zero_padded(loggerTime.second, 2) + "."
-							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+	logMessage.copy(preamble.data() + 1, logMessage.size());
+	currentSize += logMessage.size();
+	preamble[++currentSize] = ':';
+	preamble[++currentSize] = ' ';
+	preamble[++currentSize] = '|';
+	zero_padded(loggerTime.hour, 2).copy(preamble.data() + )
+	//preamble.c_str() + 1 = logMessage;
+//
+//			+ ": | " + zero_padded(loggerTime.hour, 2)
+//							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+//							+ zero_padded(loggerTime.second, 2) + "."
+//							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+	currentSize += logMessage.size(); //+ 4 +2 +1 +2 +1 +2 +1 + 3 + 3;
+	preamble[currentSize] = '\0';
+	printf("%s", preamble.c_str());
+	uint8_t debugArray[96];
+	memcpy(debugArray, preamble.data(), currentSize);
+	*preambleSize = currentSize;
 	return preamble;
 }
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 74facafe..ab5d8c90 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -19,8 +19,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
-	ServiceInterfaceBuffer(std::string setMessage, bool errStream,
-			bool addCrToPreamble, uint16_t port);
+	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+			bool buffered, bool errStream, uint16_t port);
 
 protected:
 	bool isActive;
@@ -36,11 +36,13 @@ protected:
 private:
 	//! For additional message information
 	std::string logMessage;
+	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
 
@@ -51,7 +53,7 @@ private:
 	//! In this function, the characters are parsed.
 	void putChars(char const* begin, char const* end);
 
-	std::string getPreamble();
+	std::string getPreamble(size_t * preambleSize = nullptr);
 
 	/**
 	 * This helper function returns the zero padded string version of a number.
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index d9bc980a..bef8136e 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -1,15 +1,33 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
-		bool errStream, bool addCrToPreamble, uint16_t port) :
-		std::ostream(&streambuf),
-		streambuf(setMessage, errStream, addCrToPreamble, port) {
+		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
+		std::ostream(&buf),
+		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
 }
 
 void ServiceInterfaceStream::setActive( bool myActive) {
-	this->streambuf.isActive = myActive;
+	this->buf.isActive = myActive;
 }
 
 std::string ServiceInterfaceStream::getPreamble() {
-	return streambuf.getPreamble();
+	return buf.getPreamble();
+}
+
+void ServiceInterfaceStream::print(std::string error,
+		bool withPreamble, bool withNewline, bool flush) {
+	if(not buffered and withPreamble) {
+		*this << getPreamble() << error;
+	}
+	else {
+		*this << error;
+	}
+
+	if(withNewline) {
+		*this << "\n";
+	}
+	// if mode is non-buffered, no need to flush.
+	if(flush and buffered) {
+		this->flush();
+	}
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index c44fe03a..9b8b5b6e 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -5,36 +5,28 @@
 #include <iostream>
 #include <cstdio>
 
-/* Unfortunately, there must be a forward declaration of the log front end
- * (MUST be defined in main), to let the system know where to write to.
- * The ServiceInterfaceStream instances, which are declared below and
- * can instantaited somewhere else can be passed to these front ends by passing
- * their underlying buffers with .rdbuf() */
-namespace sif {
-extern std::ostream debug;
-extern std::ostream info;
-extern std::ostream warning;
-extern std::ostream error;
-}
-
-
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
 class ServiceInterfaceStream :
         public std::ostream {
 protected:
-    ServiceInterfaceBuffer streambuf;
+    ServiceInterfaceBuffer buf;
 public:
     /**
      * This constructor is used by specifying the preamble message.
      * Optionally, the output can be directed to stderr and a CR character
      * can be prepended to the preamble.
-     * @param set_message
-     * @param errStream
-     * @param addCrToPreamble
-     * @param port
+     * @param setMessage message of preamble.
+     * @param addCrToPreamble Useful for applications like Puttty.
+     * @param buffered specify whether to use buffered mode.
+     * @param errStream specify which output stream to use (stderr or stdout).
      */
     ServiceInterfaceStream(std::string setMessage,
-    		bool errStream = false, bool addCrToPreamble = false,
-			uint16_t port = 1234);
+    		bool addCrToPreamble = false, bool buffered = true,
+			bool errStream = false, uint16_t port = 1234);
 
     //! An inactive stream will not print anything.
 	void setActive( bool );
@@ -45,15 +37,24 @@ public:
 	 * @return Preamle consisting of log message and timestamp.
 	 */
 	std::string getPreamble();
+
+	/**
+	 * This prints an error with a preamble. Useful if using the unbuffered
+	 * mode. Flushes in default mode (prints immediately).
+	 */
+	void print(std::string error, bool withPreamble = true,
+			bool withNewline = true, bool flush = true);
+
+	bool buffered = false;
 };
 
-// Forward declaration of interface streams. These are needed so the public
-// functions can be used by including this header
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
 namespace sif {
-extern ServiceInterfaceStream debugStream;
-extern ServiceInterfaceStream infoStream;
-extern ServiceInterfaceStream warningStream;
-extern ServiceInterfaceStream errorStream;
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
 }
 
 #endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

From 966c9c3993df460de712823a43c5fef04213dd53 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 14:22:04 +0200
Subject: [PATCH 06/28] buffer changes

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 52 ++++++++++++++-------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 321b1d3c..3c365f17 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -95,24 +95,40 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 		preamble[0] = '\r';
 		currentSize += 1;
 	}
-	logMessage.copy(preamble.data() + 1, logMessage.size());
-	currentSize += logMessage.size();
-	preamble[++currentSize] = ':';
-	preamble[++currentSize] = ' ';
-	preamble[++currentSize] = '|';
-	zero_padded(loggerTime.hour, 2).copy(preamble.data() + )
-	//preamble.c_str() + 1 = logMessage;
-//
-//			+ ": | " + zero_padded(loggerTime.hour, 2)
-//							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-//							+ zero_padded(loggerTime.second, 2) + "."
-//							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
-	currentSize += logMessage.size(); //+ 4 +2 +1 +2 +1 +2 +1 + 3 + 3;
-	preamble[currentSize] = '\0';
-	printf("%s", preamble.c_str());
-	uint8_t debugArray[96];
-	memcpy(debugArray, preamble.data(), currentSize);
-	*preambleSize = currentSize;
+	int32_t charCount = sprintf(preamble.data() + currentSize,
+			"%s: | %lu:%02lu:%02lu.%03lu | ",
+					this->logMessage.c_str(), (unsigned long) loggerTime.hour,
+					(unsigned long) loggerTime.minute,
+					(unsigned long) loggerTime.second,
+					(unsigned long) loggerTime.usecond /1000);
+	if(charCount < 0) {
+		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		return "";
+	}
+	currentSize += charCount;
+//	size_t currentSize = 0;
+//	if(addCrToPreamble) {
+//		preamble[0] = '\r';
+//		currentSize += 1;
+//	}
+//	logMessage.copy(preamble.data() + 1, logMessage.size());
+//	currentSize += logMessage.size();
+//	preamble[++currentSize] = ':';
+//	preamble[++currentSize] = ' ';
+//	preamble[++currentSize] = '|';
+//	zero_padded(loggerTime.hour, 2).copy(preamble.data() + )
+//	//preamble.c_str() + 1 = logMessage;
+////
+////			+ ": | " + zero_padded(loggerTime.hour, 2)
+////							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
+////							+ zero_padded(loggerTime.second, 2) + "."
+////							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
+//	currentSize += logMessage.size(); //+ 4 +2 +1 +2 +1 +2 +1 + 3 + 3;
+//	preamble[currentSize] = '\0';
+//	printf("%s", preamble.c_str());
+//	uint8_t debugArray[96];
+//	memcpy(debugArray, preamble.data(), currentSize);
+//	*preambleSize = currentSize;
 	return preamble;
 }
 

From 1cb241ca0cb3ab729b4bf67167a3e36f5dc2bcb3 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 17:30:09 +0200
Subject: [PATCH 07/28] zero padded not using dyn mem alloc now

---
 serviceinterface/ServiceInterfaceBuffer.h | 31 ++++++++++++++++-------
 1 file changed, 22 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index ab5d8c90..a032691c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -1,6 +1,7 @@
 #ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 #define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
 
+#include <framework/returnvalues/HasReturnvaluesIF.h>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
@@ -58,21 +59,33 @@ private:
 	/**
 	 * This helper function returns the zero padded string version of a number.
 	 * The type is deduced automatically.
+	 * TODO: This uses dynamic memory allocation, so we should provide
+	 * a custom streambuf class to use it (which takes maxSize as argument)
+	 * Then we would propably
 	 * @tparam T
 	 * @param num
 	 * @param width
 	 * @return
 	 */
 	template<typename T>
-	std::string zero_padded(const T& num, uint8_t width) {
-	    std::ostringstream string_to_pad;
-	    string_to_pad << std::setw(width) << std::setfill('0') << num;
-	    std::string result = string_to_pad.str();
-	    if (result.length() > width)
-	    {
-	        result.erase(0, result.length() - width);
-	    }
-	    return result;
+	ReturnValue_t zeroPadded(std::string stringToFill, const T& num,
+			uint8_t width) {
+		auto numString = std::to_string(num);
+		uint8_t i = 0;
+		for(i = 0; i < width; i++) {
+			stringToFill[i] = '0';
+		}
+		numString.copy(stringToFill.data() + i, numString.size());
+//		std::streambuf streambuf;
+//	    std::ostringstream string_to_pad;
+//	    string_to_pad << std::setw(width) << std::setfill('0') << num;
+//	    std::string result = string_to_pad.str();
+//	    if (result.length() > width)
+//	    {
+//	        result.erase(0, result.length() - width);
+//	    }
+//	    return result;
+	    //std::string dest = std::string( number_of_zeros, '0').append( original_string);
 	}
 };
 

From d466921aa0f5ac1adc8fe8b95f83d8b518eb7653 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 17:58:22 +0200
Subject: [PATCH 08/28] some more experiments

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 3c365f17..7cf75a36 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -75,6 +75,8 @@ int ServiceInterfaceBuffer::sync(void) {
 
 	size_t preambleSize  = 0;
 	auto preamble = getPreamble(&preambleSize);
+	uint8_t debugArray[96];
+	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
 	this->putChars(preamble.c_str(), preamble.c_str() + preambleSize);
 	// Handle output
@@ -124,12 +126,11 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 ////							+ zero_padded(loggerTime.second, 2) + "."
 ////							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
 //	currentSize += logMessage.size(); //+ 4 +2 +1 +2 +1 +2 +1 + 3 + 3;
-//	preamble[currentSize] = '\0';
-//	printf("%s", preamble.c_str());
-//	uint8_t debugArray[96];
-//	memcpy(debugArray, preamble.data(), currentSize);
-//	*preambleSize = currentSize;
-	return preamble;
+	preamble[++currentSize] = '\0';
+	uint8_t debugArray[96];
+	memcpy(debugArray, preamble.data(), currentSize);
+	*preambleSize = currentSize;
+	return std::move(preamble);
 }
 
 

From c0808e71d99324fd40082bbbbb16d4cbbff9a7ab Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:07:04 +0200
Subject: [PATCH 09/28] no dyn memory allocation, print seems to work

---
 objectmanager/ObjectManagerIF.h             |  1 -
 serviceinterface/ServiceInterfaceBuffer.cpp | 48 +++++++--------------
 serviceinterface/ServiceInterfaceBuffer.h   | 18 +-------
 3 files changed, 17 insertions(+), 50 deletions(-)

diff --git a/objectmanager/ObjectManagerIF.h b/objectmanager/ObjectManagerIF.h
index aca24a24..830aa400 100644
--- a/objectmanager/ObjectManagerIF.h
+++ b/objectmanager/ObjectManagerIF.h
@@ -9,7 +9,6 @@
 #define OBJECTMANAGERIF_H_
 
 #include <framework/objectmanager/frameworkObjects.h>
-#include <config/objects/systemObjectList.h>
 #include <framework/objectmanager/SystemObjectIF.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 7cf75a36..30149ce0 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -1,6 +1,7 @@
 #include <framework/timemanager/Clock.h>
 #include <framework/serviceinterface/ServiceInterfaceBuffer.h>
 #include <cstring>
+#include <inttypes.h>
 
 // to be implemented by bsp
 extern "C" void printChar(const char*, bool errStream);
@@ -17,6 +18,7 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		setp( buf, buf + BUF_SIZE );
 	}
 	preamble.reserve(96);
+	preamble.resize(96);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -78,7 +80,7 @@ int ServiceInterfaceBuffer::sync(void) {
 	uint8_t debugArray[96];
 	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
-	this->putChars(preamble.c_str(), preamble.c_str() + preambleSize);
+	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
 	this->putChars(pbase(), pptr());
 	// This tells that buffer is empty again
@@ -90,47 +92,29 @@ int ServiceInterfaceBuffer::sync(void) {
 std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	//preamble.clear();
-	//std::string preamble;
+	std::string preamble (96, 0);
 	size_t currentSize = 0;
+	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
 		preamble[0] = '\r';
 		currentSize += 1;
+		parsePosition += 1;
 	}
-	int32_t charCount = sprintf(preamble.data() + currentSize,
-			"%s: | %lu:%02lu:%02lu.%03lu | ",
-					this->logMessage.c_str(), (unsigned long) loggerTime.hour,
-					(unsigned long) loggerTime.minute,
-					(unsigned long) loggerTime.second,
-					(unsigned long) loggerTime.usecond /1000);
+	int32_t charCount = sprintf(parsePosition,
+			"%s: | %02" SCNu32 ":%02" SCNu32 ":%02" SCNu32 ".%03" SCNu32 " | ",
+					this->logMessage.c_str(), loggerTime.hour,
+					loggerTime.minute,
+					loggerTime.second,
+					loggerTime.usecond /1000);
 	if(charCount < 0) {
 		printf("ServiceInterfaceBuffer: Failure parsing preamble");
 		return "";
 	}
 	currentSize += charCount;
-//	size_t currentSize = 0;
-//	if(addCrToPreamble) {
-//		preamble[0] = '\r';
-//		currentSize += 1;
-//	}
-//	logMessage.copy(preamble.data() + 1, logMessage.size());
-//	currentSize += logMessage.size();
-//	preamble[++currentSize] = ':';
-//	preamble[++currentSize] = ' ';
-//	preamble[++currentSize] = '|';
-//	zero_padded(loggerTime.hour, 2).copy(preamble.data() + )
-//	//preamble.c_str() + 1 = logMessage;
-////
-////			+ ": | " + zero_padded(loggerTime.hour, 2)
-////							+ ":" + zero_padded(loggerTime.minute, 2) + ":"
-////							+ zero_padded(loggerTime.second, 2) + "."
-////							+ zero_padded(loggerTime.usecond/1000, 3) + " | ";
-//	currentSize += logMessage.size(); //+ 4 +2 +1 +2 +1 +2 +1 + 3 + 3;
-	preamble[++currentSize] = '\0';
-	uint8_t debugArray[96];
-	memcpy(debugArray, preamble.data(), currentSize);
-	*preambleSize = currentSize;
-	return std::move(preamble);
+	if(preambleSize != nullptr) {
+		*preambleSize = currentSize;
+	}
+	return preamble;
 }
 
 
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index a032691c..9a4ae479 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -76,29 +76,13 @@ private:
 			stringToFill[i] = '0';
 		}
 		numString.copy(stringToFill.data() + i, numString.size());
-//		std::streambuf streambuf;
-//	    std::ostringstream string_to_pad;
-//	    string_to_pad << std::setw(width) << std::setfill('0') << num;
-//	    std::string result = string_to_pad.str();
-//	    if (result.length() > width)
-//	    {
-//	        result.erase(0, result.length() - width);
-//	    }
-//	    return result;
-	    //std::string dest = std::string( number_of_zeros, '0').append( original_string);
+		return HasReturnvaluesIF::RETURN_OK;
 	}
 };
 
 #endif
 
 
-
-
-
-
-
-
-
 #ifdef UT699
 class ServiceInterfaceBuffer: public std::basic_streambuf<char,
 		std::char_traits<char> > {

From 3a573c1b4c460cb19163d8bb9f319b501657f1e8 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:37:33 +0200
Subject: [PATCH 10/28] no run-time dyn memory allocation now

---
 serviceinterface/ServiceInterfaceBuffer.cpp |  8 +++++-
 serviceinterface/ServiceInterfaceBuffer.h   | 28 ++----------------
 serviceinterface/ServiceInterfaceStream.cpp | 13 ++++-----
 serviceinterface/ServiceInterfaceStream.h   | 32 ++++++++++-----------
 4 files changed, 31 insertions(+), 50 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index 30149ce0..f1332637 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -68,12 +68,15 @@ int ServiceInterfaceBuffer::overflow(int c) {
 }
 
 int ServiceInterfaceBuffer::sync(void) {
-	if(not this->isActive) {
+	if(not this->isActive and not buffered) {
 		if(not buffered) {
 			setp(buf, buf + BUF_SIZE - 1);
 		}
 		return 0;
 	}
+	if(not buffered) {
+		return 0;
+	}
 
 	size_t preambleSize  = 0;
 	auto preamble = getPreamble(&preambleSize);
@@ -88,6 +91,9 @@ int ServiceInterfaceBuffer::sync(void) {
 	return 0;
 }
 
+bool ServiceInterfaceBuffer::isBuffered() const {
+	return buffered;
+}
 
 std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 9a4ae479..00a8e74a 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -34,6 +34,7 @@ protected:
 	//! for example when std::endl is put to stream.
 	int sync(void) override;
 
+	bool isBuffered() const;
 private:
 	//! For additional message information
 	std::string logMessage;
@@ -43,10 +44,10 @@ private:
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
-	bool buffered;
+
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-
+	bool buffered;
 	// Work in buffer mode. It is also possible to work without buffer.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
@@ -55,29 +56,6 @@ private:
 	void putChars(char const* begin, char const* end);
 
 	std::string getPreamble(size_t * preambleSize = nullptr);
-
-	/**
-	 * This helper function returns the zero padded string version of a number.
-	 * The type is deduced automatically.
-	 * TODO: This uses dynamic memory allocation, so we should provide
-	 * a custom streambuf class to use it (which takes maxSize as argument)
-	 * Then we would propably
-	 * @tparam T
-	 * @param num
-	 * @param width
-	 * @return
-	 */
-	template<typename T>
-	ReturnValue_t zeroPadded(std::string stringToFill, const T& num,
-			uint8_t width) {
-		auto numString = std::to_string(num);
-		uint8_t i = 0;
-		for(i = 0; i < width; i++) {
-			stringToFill[i] = '0';
-		}
-		numString.copy(stringToFill.data() + i, numString.size());
-		return HasReturnvaluesIF::RETURN_OK;
-	}
 };
 
 #endif
diff --git a/serviceinterface/ServiceInterfaceStream.cpp b/serviceinterface/ServiceInterfaceStream.cpp
index bef8136e..76481ed1 100644
--- a/serviceinterface/ServiceInterfaceStream.cpp
+++ b/serviceinterface/ServiceInterfaceStream.cpp
@@ -2,21 +2,20 @@
 
 ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage,
 		bool addCrToPreamble, bool buffered, bool errStream, uint16_t port) :
-		std::ostream(&buf),
-		buf(setMessage, addCrToPreamble, buffered, errStream,  port) {
-}
+		std::ostream(&streambuf),
+		streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
 
 void ServiceInterfaceStream::setActive( bool myActive) {
-	this->buf.isActive = myActive;
+	this->streambuf.isActive = myActive;
 }
 
 std::string ServiceInterfaceStream::getPreamble() {
-	return buf.getPreamble();
+	return streambuf.getPreamble();
 }
 
 void ServiceInterfaceStream::print(std::string error,
 		bool withPreamble, bool withNewline, bool flush) {
-	if(not buffered and withPreamble) {
+	if(not streambuf.isBuffered() and withPreamble) {
 		*this << getPreamble() << error;
 	}
 	else {
@@ -27,7 +26,7 @@ void ServiceInterfaceStream::print(std::string error,
 		*this << "\n";
 	}
 	// if mode is non-buffered, no need to flush.
-	if(flush and buffered) {
+	if(flush and streambuf.isBuffered()) {
 		this->flush();
 	}
 }
diff --git a/serviceinterface/ServiceInterfaceStream.h b/serviceinterface/ServiceInterfaceStream.h
index 9b8b5b6e..9e19c228 100644
--- a/serviceinterface/ServiceInterfaceStream.h
+++ b/serviceinterface/ServiceInterfaceStream.h
@@ -10,25 +10,22 @@
  * std::cerr but has additional capability. Add preamble and timestamp
  * to output. Can be run in buffered or unbuffered mode.
  */
-class ServiceInterfaceStream :
-        public std::ostream {
-protected:
-    ServiceInterfaceBuffer buf;
+class ServiceInterfaceStream : public std::ostream {
 public:
-    /**
-     * This constructor is used by specifying the preamble message.
-     * Optionally, the output can be directed to stderr and a CR character
-     * can be prepended to the preamble.
-     * @param setMessage message of preamble.
-     * @param addCrToPreamble Useful for applications like Puttty.
-     * @param buffered specify whether to use buffered mode.
-     * @param errStream specify which output stream to use (stderr or stdout).
-     */
-    ServiceInterfaceStream(std::string setMessage,
-    		bool addCrToPreamble = false, bool buffered = true,
+	/**
+	 * This constructor is used by specifying the preamble message.
+	 * Optionally, the output can be directed to stderr and a CR character
+	 * can be prepended to the preamble.
+	 * @param setMessage message of preamble.
+	 * @param addCrToPreamble Useful for applications like Puttty.
+	 * @param buffered specify whether to use buffered mode.
+	 * @param errStream specify which output stream to use (stderr or stdout).
+	 */
+	ServiceInterfaceStream(std::string setMessage,
+			bool addCrToPreamble = false, bool buffered = true,
 			bool errStream = false, uint16_t port = 1234);
 
-    //! An inactive stream will not print anything.
+	//! An inactive stream will not print anything.
 	void setActive( bool );
 
 	/**
@@ -45,7 +42,8 @@ public:
 	void print(std::string error, bool withPreamble = true,
 			bool withNewline = true, bool flush = true);
 
-	bool buffered = false;
+protected:
+	ServiceInterfaceBuffer streambuf;
 };
 
 // Forward declaration of interface streams. These should be instantiated in

From 7014833c1c89938d0475e88a7a57b628933051e5 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:50:56 +0200
Subject: [PATCH 11/28] improvements and fixes

---
 serviceinterface/ServiceInterfaceBuffer.cpp | 15 ++++++++-------
 serviceinterface/ServiceInterfaceBuffer.h   |  9 +++++++--
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/serviceinterface/ServiceInterfaceBuffer.cpp b/serviceinterface/ServiceInterfaceBuffer.cpp
index f1332637..5c80862c 100644
--- a/serviceinterface/ServiceInterfaceBuffer.cpp
+++ b/serviceinterface/ServiceInterfaceBuffer.cpp
@@ -17,8 +17,8 @@ ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage,
 		// Set pointers if the stream is buffered.
 		setp( buf, buf + BUF_SIZE );
 	}
-	preamble.reserve(96);
-	preamble.resize(96);
+	preamble.reserve(MAX_PREAMBLE_SIZE);
+	preamble.resize(MAX_PREAMBLE_SIZE);
 }
 
 void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
@@ -36,7 +36,6 @@ void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
 		else {
 			printChar(begin, false);
 		}
-
 	}
 }
 
@@ -80,8 +79,6 @@ int ServiceInterfaceBuffer::sync(void) {
 
 	size_t preambleSize  = 0;
 	auto preamble = getPreamble(&preambleSize);
-	uint8_t debugArray[96];
-	memcpy(debugArray, preamble.data(), preambleSize);
 	// Write logMessage and time
 	this->putChars(preamble.data(), preamble.data() + preambleSize);
 	// Handle output
@@ -98,7 +95,6 @@ bool ServiceInterfaceBuffer::isBuffered() const {
 std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 	Clock::TimeOfDay_t loggerTime;
 	Clock::getDateAndTime(&loggerTime);
-	std::string preamble (96, 0);
 	size_t currentSize = 0;
 	char* parsePosition = &preamble[0];
 	if(addCrToPreamble) {
@@ -113,7 +109,12 @@ std::string ServiceInterfaceBuffer::getPreamble(size_t * preambleSize) {
 					loggerTime.second,
 					loggerTime.usecond /1000);
 	if(charCount < 0) {
-		printf("ServiceInterfaceBuffer: Failure parsing preamble");
+		printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+		return "";
+	}
+	if(charCount > MAX_PREAMBLE_SIZE) {
+		printf("ServiceInterfaceBuffer: Char count too large for maximum "
+				"preamble size");
 		return "";
 	}
 	currentSize += charCount;
diff --git a/serviceinterface/ServiceInterfaceBuffer.h b/serviceinterface/ServiceInterfaceBuffer.h
index 00a8e74a..39ea25c2 100644
--- a/serviceinterface/ServiceInterfaceBuffer.h
+++ b/serviceinterface/ServiceInterfaceBuffer.h
@@ -20,6 +20,8 @@ class ServiceInterfaceBuffer:
         public std::streambuf {
 	friend class ServiceInterfaceStream;
 public:
+	static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
 	ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
 			bool buffered, bool errStream, uint16_t port);
 
@@ -41,14 +43,17 @@ private:
 	std::string preamble;
 	// For EOF detection
 	typedef std::char_traits<char> Traits;
+
 	//! This is useful for some terminal programs which do not have
 	//! implicit carriage return with newline characters.
 	bool addCrToPreamble;
 
+	//! Specifies whether the stream operates in buffered or unbuffered mode.
+	bool buffered;
 	//! This specifies to print to stderr and work in unbuffered mode.
 	bool errStream;
-	bool buffered;
-	// Work in buffer mode. It is also possible to work without buffer.
+
+	//! Needed for buffered mode.
 	static size_t const BUF_SIZE = 128;
 	char buf[BUF_SIZE];
 

From 639b517edaffc63094870cd1bcdcdb9bed9229ca Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 4 Jun 2020 19:57:25 +0200
Subject: [PATCH 12/28] removed unnecessary change

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 549ffbf1..fb3c3b03 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -68,7 +68,7 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 	}
 
 	sif::error << "Component " << std::hex << componentId <<
-			" not found, not adding it to pst\r" << std::endl;
+			" not found, not adding it to pst" << std::endl;
 	return HasReturnvaluesIF::RETURN_FAILED;
 }
 

From 0c4552254089de1b5626a4bca31114acb39a0290 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 17 Jun 2020 20:57:35 +0200
Subject: [PATCH 13/28] hybrid iterator fix and improvement

---
 container/HybridIterator.h | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index b34fdfd0..db1ce4bc 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -8,13 +8,11 @@ template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
 		public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() :
-			value(NULL), linked(NULL), end(NULL) {
-	}
+	HybridIterator() {}
 
 	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(
-					iter->value), linked(true), end(NULL) {
+		LinkedElement<T>::Iterator(*iter), value(iter->value),
+		linked(true) {
 
 	}
 
@@ -66,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(HybridIterator other) {
-		return value == other->value;
+	bool operator==(const HybridIterator& other) {
+		return value == other.value;
 	}
 
-	bool operator!=(HybridIterator other) {
+	bool operator!=(const HybridIterator& other) {
 		return !(*this == other);
 	}
 
@@ -82,11 +80,11 @@ public:
 		return value;
 	}
 
-	T* value;
+	T* value = nullptr;
 
 private:
-	bool linked;
-	T *end;
+	bool linked = false;
+	T *end = nullptr;
 };
 
 #endif /* HYBRIDITERATOR_H_ */

From 56aaa299854f4a7e0cf02499cdb2cb11db0899b9 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 19 Jun 2020 14:47:01 +0200
Subject: [PATCH 14/28] added deadline missed check

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 64 ++++++++++++++++----------
 osal/FreeRTOS/FixedTimeslotTask.h   | 69 ++++++++++++++++-------------
 2 files changed, 77 insertions(+), 56 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index fb3c3b03..ea324d35 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -1,6 +1,7 @@
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include "FixedTimeslotTask.h"
 
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
 
@@ -18,16 +19,19 @@ FixedTimeslotTask::~FixedTimeslotTask() {
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
 
-	//The argument is re-interpreted as FixedTimeslotTask. The Task object is global, so it is found from any place.
+	// The argument is re-interpreted as FixedTimeslotTask. The Task object is
+    // global, so it is found from any place.
 	FixedTimeslotTask *originalTask(reinterpret_cast<FixedTimeslotTask*>(argument));
-	// Task should not start until explicitly requested
-	// in FreeRTOS, tasks start as soon as they are created if the scheduler is running
-	// but not if the scheduler is not running.
-	// to be able to accommodate both cases we check a member which is set in #startTask()
-	// if it is not set and we get here, the scheduler was started before #startTask() was called and we need to suspend
-	// if it is set, the scheduler was not running before #startTask() was called and we can continue
+	/* Task should not start until explicitly requested,
+	 * but in FreeRTOS, tasks start as soon as they are created if the scheduler
+	 * is running but not if the scheduler is not running.
+	 * To be able to accommodate both cases we check a member which is set in
+	 * #startTask(). If it is not set and we get here, the scheduler was started
+	 * before #startTask() was called and we need to suspend if it is set,
+	 * the scheduler was not running before #startTask() was called and we
+	 * can continue */
 
-	if (!originalTask->started) {
+	if (not originalTask->started) {
 		vTaskSuspend(NULL);
 	}
 
@@ -81,11 +85,12 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 }
 
 void FixedTimeslotTask::taskFunctionality() {
-	// A local iterator for the Polling Sequence Table is created to find the start time for the first entry.
-	std::list<FixedSequenceSlot*>::iterator it = pst.current;
+	// A local iterator for the Polling Sequence Table is created to find the
+    // start time for the first entry.
+	SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = (*it)->pollingTimeMs;
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;
@@ -101,18 +106,30 @@ void FixedTimeslotTask::taskFunctionality() {
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		//The component for this slot is executed and the next one is chosen.
-		this->pst.executeAndAdvance();
-		if (pst.slotFollowsImmediately()) {
-			//Do nothing
-		} else {
-			// we need to wait before executing the current slot
-			//this gives us the time to wait:
-			intervalMs = this->pst.getIntervalToPreviousSlotMs();
-			interval = pdMS_TO_TICKS(intervalMs);
-			vTaskDelayUntil(&xLastWakeTime, interval);
-			//TODO deadline missed check
-		}
+	    this->pst.executeAndAdvance();
+	    if (not pst.slotFollowsImmediately()) {
+	        /* If all operations are finished and the difference of the
+	         * current time minus the last wake time is larger than the
+	         * expected wait period, a deadline was missed. */
+	        if(xTaskGetTickCount() - xLastWakeTime >=
+	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+#ifdef DEBUG
+	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+	                    " missed deadline!\n" << std::flush;
+#endif
+	            if(deadlineMissedFunc != nullptr) {
+	                this->deadlineMissedFunc();
+	            }
+	            // Continue immediately, no need to wait.
+	            break;
+	        }
 
+	        // we need to wait before executing the current slot
+	        //this gives us the time to wait:
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+	        vTaskDelayUntil(&xLastWakeTime, interval);
+	    }
 	}
 }
 
@@ -120,4 +137,3 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
-
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index bed13051..39db667c 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -1,24 +1,27 @@
-#ifndef POLLINGTASK_H_
-#define POLLINGTASK_H_
+#ifndef FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
+#define FRAMEWORK_OSAL_FREERTOS_FIXEDTIMESLOTTASK_H_
 
 #include <framework/devicehandlers/FixedSlotSequence.h>
 #include <framework/tasks/FixedTimeslotTaskIF.h>
 #include <framework/tasks/Typedef.h>
 
-#include <FreeRTOS.h>
-#include "task.h"
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
 
 class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
+
 	/**
-	 * @brief	The standard constructor of the class.
-	 *
-	 * @details	This is the general constructor of the class. In addition to the TaskBase parameters,
-	 * 			the following variables are passed:
-	 *
-	 * @param	(*setDeadlineMissedFunc)() The function pointer to the deadline missed function that shall be assigned.
-	 *
-	 * @param	getPst The object id of the completely initialized polling sequence.
+	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * A lot of task parameters are set in "FreeRTOSConfig.h".
+	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
+	 * @param setPriority Number of priorities specified by
+	 * configMAX_PRIORITIES. High taskPriority_ number means high priority.
+	 * @param setStack	Stack size in words (not bytes!).
+	 * Lower limit specified by configMINIMAL_STACK_SIZE
+	 * @param overallPeriod		Period in seconds.
+	 * @param setDeadlineMissedFunc Callback if a deadline was missed.
+	 * @return Pointer to the newly created task.
 	 */
 	FixedTimeslotTask(const char *name, TaskPriority setPriority,
 			TaskStackSize setStack, TaskPeriod overallPeriod,
@@ -26,16 +29,18 @@ public:
 
 	/**
 	 * @brief	The destructor of the class.
-	 *
-	 * @details	The destructor frees all heap memory that was allocated on thread initialization for the PST and
-	 * 			the device handlers. This is done by calling the PST's destructor.
+	 * @details
+	 * The destructor frees all heap memory that was allocated on thread
+	 * initialization for the PST and the device handlers. This is done by
+	 * calling the PST's destructor.
 	 */
 	virtual ~FixedTimeslotTask(void);
 
 	ReturnValue_t startTask(void);
 	/**
 	 * This static function can be used as #deadlineMissedFunc.
-	 * It counts missedDeadlines and prints the number of missed deadlines every 10th time.
+	 * It counts missedDeadlines and prints the number of missed deadlines
+	 * every 10th time.
 	 */
 	static void missedDeadlineCounter();
 	/**
@@ -51,6 +56,7 @@ public:
 	ReturnValue_t checkSequence() const;
 
 	ReturnValue_t sleepFor(uint32_t ms);
+
 protected:
 	bool started;
 	TaskHandle_t handle;
@@ -58,30 +64,29 @@ protected:
 	FixedSlotSequence pst;
 
 	/**
-	 * @brief	This attribute holds a function pointer that is executed when a deadline was missed.
-	 *
-	 * @details	Another function may be announced to determine the actions to perform when a deadline was missed.
-	 * 			Currently, only one function for missing any deadline is allowed.
-	 * 			If not used, it shall be declared NULL.
+	 * @brief	This attribute holds a function pointer that is executed when
+	 *          a deadline was missed.
+	 * @details
+	 * Another function may be announced to determine the actions to perform
+	 * when a deadline was missed. Currently, only one function for missing
+	 * any deadline is allowed. If not used, it shall be declared NULL.
 	 */
 	void (*deadlineMissedFunc)(void);
 	/**
-	 * @brief	This is the entry point in a new polling thread.
-	 *
-	 * @details	This method, that is the generalOSAL::checkAndRestartPeriod( this->periodId, interval ); entry point in the new thread, is here set to generate
-	 * 			and link the Polling Sequence Table to the thread object and start taskFunctionality()
-	 * 			on success. If operation of the task is ended for some reason,
-	 * 			the destructor is called to free allocated memory.
+	 * @brief	This is the entry point for a new task.
+	 * @details
+	 * This method starts the task by calling taskFunctionality(), as soon as
+	 * all requirements (task scheduler has started and startTask()
+	 * has been called) are met.
 	 */
 	static void taskEntryPoint(void* argument);
 
 	/**
 	 * @brief	This function holds the main functionality of the thread.
-	 *
-	 *
-	 * @details	Holding the main functionality of the task, this method is most important.
-	 * 			It links the functionalities provided by FixedSlotSequence with the OS's System Calls
-	 * 			to keep the timing of the periods.
+	 * @details
+	 * Core function holding the main functionality of the task
+	 * It links the functionalities provided by FixedSlotSequence with the
+	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
 };

From ffe2a7bffefbb744d1149e4c4d53807649c0570e Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 19:00:02 +0200
Subject: [PATCH 15/28] fix for fixed timeslot task improvement

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index ea324d35..a4acc420 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -87,10 +87,10 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the
     // start time for the first entry.
-	SlotListIter slotListIter = pst.current;
+    std::list<FixedSequenceSlot*>::iterator slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = slotListIter->pollingTimeMs;
+	uint32_t intervalMs = (*slotListIter)->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;
@@ -121,7 +121,7 @@ void FixedTimeslotTask::taskFunctionality() {
 	                this->deadlineMissedFunc();
 	            }
 	            // Continue immediately, no need to wait.
-	            break;
+	            continue;
 	        }
 
 	        // we need to wait before executing the current slot

From 2cada2df4a611daf5d8c9e6bfa1e8026dc98e09b Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 20:21:11 +0200
Subject: [PATCH 16/28] some fixes and improvements

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index a4acc420..edb7f835 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -62,11 +62,6 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	if (objectManager->get<ExecutableObjectIF>(componentId) != nullptr) {
-		if(slotTimeMs == 0) {
-			// FreeRTOS throws a sanity error for zero values, so we set
-			// the time to one millisecond.
-			slotTimeMs = 1;
-		}
 		pst.addSlot(componentId, slotTimeMs, executionStep, this);
 		return HasReturnvaluesIF::RETURN_OK;
 	}
@@ -87,7 +82,7 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the
     // start time for the first entry.
-    std::list<FixedSequenceSlot*>::iterator slotListIter = pst.current;
+	auto slotListIter = pst.current;
 
 	//The start time for the first entry is read.
 	uint32_t intervalMs = (*slotListIter)->pollingTimeMs;
@@ -101,18 +96,23 @@ void FixedTimeslotTask::taskFunctionality() {
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time
-	vTaskDelayUntil(&xLastWakeTime, interval);
+	if(interval > 0) {
+	    vTaskDelayUntil(&xLastWakeTime, interval);
+	}
 
 	/* Enter the loop that defines the task behavior. */
 	for (;;) {
 		//The component for this slot is executed and the next one is chosen.
 	    this->pst.executeAndAdvance();
 	    if (not pst.slotFollowsImmediately()) {
+	        // Get the interval till execution of the next slot.
+	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
+	        interval = pdMS_TO_TICKS(intervalMs);
+
 	        /* If all operations are finished and the difference of the
 	         * current time minus the last wake time is larger than the
 	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >=
-	                pdMS_TO_TICKS(this->pst.getIntervalToPreviousSlotMs())) {
+	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
 #ifdef DEBUG
 	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;
@@ -120,14 +120,9 @@ void FixedTimeslotTask::taskFunctionality() {
 	            if(deadlineMissedFunc != nullptr) {
 	                this->deadlineMissedFunc();
 	            }
-	            // Continue immediately, no need to wait.
-	            continue;
 	        }
-
-	        // we need to wait before executing the current slot
-	        //this gives us the time to wait:
-	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
-	        interval = pdMS_TO_TICKS(intervalMs);
+	        // Wait for the interval. This exits immediately if a deadline was
+	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
 	    }
 	}
@@ -137,3 +132,4 @@ ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
 }
+

From 3c7ac60dbe2e2e623f6aea1d746418335a2a6dbe Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 20:39:36 +0200
Subject: [PATCH 17/28] added overflow checking

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index edb7f835..d92474c7 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -111,8 +111,15 @@ void FixedTimeslotTask::taskFunctionality() {
 
 	        /* If all operations are finished and the difference of the
 	         * current time minus the last wake time is larger than the
-	         * expected wait period, a deadline was missed. */
-	        if(xTaskGetTickCount() - xLastWakeTime >= interval) {
+	         * expected wait period, a deadline was missed.
+	         * We also check whether an overflow has occured first.
+	         * In this special case, we will ignore missed deadlines for now. */
+	        const TickType_t constTickCount = xTaskGetTickCount();
+	        if(constTickCount < xLastWakeTime or
+	                constTickCount + interval < xLastWakeTime) {
+	            // don't do anything for now.
+	        }
+	        else if(xTaskGetTickCount() - xLastWakeTime >= interval) {
 #ifdef DEBUG
 	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
 	                    " missed deadline!\n" << std::flush;

From bf63ba15fedfacd7ae19de5298d49a0a05154aae Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:30:17 +0200
Subject: [PATCH 18/28] finished overflow checking (hopefully)

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 55 +++++++++++++++++++----------
 osal/FreeRTOS/FixedTimeslotTask.h   |  4 +++
 2 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index d92474c7..d72354ae 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -109,25 +109,8 @@ void FixedTimeslotTask::taskFunctionality() {
 	        intervalMs = this->pst.getIntervalToPreviousSlotMs();
 	        interval = pdMS_TO_TICKS(intervalMs);
 
-	        /* If all operations are finished and the difference of the
-	         * current time minus the last wake time is larger than the
-	         * expected wait period, a deadline was missed.
-	         * We also check whether an overflow has occured first.
-	         * In this special case, we will ignore missed deadlines for now. */
-	        const TickType_t constTickCount = xTaskGetTickCount();
-	        if(constTickCount < xLastWakeTime or
-	                constTickCount + interval < xLastWakeTime) {
-	            // don't do anything for now.
-	        }
-	        else if(xTaskGetTickCount() - xLastWakeTime >= interval) {
-#ifdef DEBUG
-	            sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
-	                    " missed deadline!\n" << std::flush;
-#endif
-	            if(deadlineMissedFunc != nullptr) {
-	                this->deadlineMissedFunc();
-	            }
-	        }
+	        checkMissedDeadline(xLastWakeTime, interval);
+
 	        // Wait for the interval. This exits immediately if a deadline was
 	        // missed while also updating the last wake time.
 	        vTaskDelayUntil(&xLastWakeTime, interval);
@@ -135,6 +118,40 @@ void FixedTimeslotTask::taskFunctionality() {
 	}
 }
 
+void FixedTimeslotTask::checkMissedDeadline(const TickType_t xLastWakeTime,
+        const TickType_t interval) {
+    /* Check whether deadline was missed while also taking overflows
+     * into account. Drawing this on paper with a timeline helps to understand
+     * it. */
+    TickType_t currentTickCount = xTaskGetTickCount();
+    TickType_t timeToWake = xLastWakeTime + interval;
+    // Tick count has overflown
+    if(currentTickCount < xLastWakeTime) {
+        // Time to wake has overflown as well. If the tick count
+        // is larger than the time to wake, a deadline was missed.
+        if(timeToWake < xLastWakeTime and
+                currentTickCount > timeToWake) {
+            handleMissedDeadline();
+        }
+    }
+    // No tick count overflow. If the timeToWake has not overflown
+    // and the current tick count is larger than the time to wake,
+    // a deadline was missed.
+    else if(timeToWake > xLastWakeTime and currentTickCount > timeToWake) {
+        handleMissedDeadline();
+    }
+}
+
+void FixedTimeslotTask::handleMissedDeadline() {
+#ifdef DEBUG
+    sif::warning << "FixedTimeslotTask: " << pcTaskGetName(NULL) <<
+            " missed deadline!\n" << std::flush;
+#endif
+    if(deadlineMissedFunc != nullptr) {
+        this->deadlineMissedFunc();
+    }
+}
+
 ReturnValue_t FixedTimeslotTask::sleepFor(uint32_t ms) {
 	vTaskDelay(pdMS_TO_TICKS(ms));
 	return HasReturnvaluesIF::RETURN_OK;
diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index 39db667c..cddd5ecd 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -89,6 +89,10 @@ protected:
 	 * OS's System Calls to keep the timing of the periods.
 	 */
 	void taskFunctionality(void);
+
+	void checkMissedDeadline(const TickType_t xLastWakeTime,
+	        const TickType_t interval);
+	void handleMissedDeadline();
 };
 
 #endif /* POLLINGTASK_H_ */

From 0c9c9c581ba1aa05acc9de1e6af9528c99b1a4fd Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:31:27 +0200
Subject: [PATCH 19/28] minor formatting

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index d72354ae..871b7922 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -90,9 +90,9 @@ void FixedTimeslotTask::taskFunctionality() {
 
 	TickType_t xLastWakeTime;
 	/* The xLastWakeTime variable needs to be initialized with the current tick
-	 count. Note that this is the only time the variable is written to explicitly.
-	 After this assignment, xLastWakeTime is updated automatically internally within
-	 vTaskDelayUntil(). */
+	 count. Note that this is the only time the variable is written to
+	 explicitly. After this assignment, xLastWakeTime is updated automatically
+	 internally within vTaskDelayUntil(). */
 	xLastWakeTime = xTaskGetTickCount();
 
 	// wait for first entry's start time

From 1cc50639c7ca8d99377d6bc753f9c6815469b659 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 22 Jun 2020 23:49:31 +0200
Subject: [PATCH 20/28] improvements integrated

---
 osal/FreeRTOS/FixedTimeslotTask.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.h b/osal/FreeRTOS/FixedTimeslotTask.h
index cddd5ecd..08a9c3b3 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.h
+++ b/osal/FreeRTOS/FixedTimeslotTask.h
@@ -12,7 +12,7 @@ class FixedTimeslotTask: public FixedTimeslotTaskIF {
 public:
 
 	/**
-	 * Keep in Mind that you need to call before this vTaskStartScheduler()!
+	 * Keep in mind that you need to call before vTaskStartScheduler()!
 	 * A lot of task parameters are set in "FreeRTOSConfig.h".
 	 * @param name Name of the task, lenght limited by configMAX_TASK_NAME_LEN
 	 * @param setPriority Number of priorities specified by
@@ -49,13 +49,13 @@ public:
 	static uint32_t deadlineMissedCount;
 
 	ReturnValue_t addSlot(object_id_t componentId, uint32_t slotTimeMs,
-			int8_t executionStep);
+			int8_t executionStep) override;
 
-	uint32_t getPeriodMs() const;
+	uint32_t getPeriodMs() const override;
 
-	ReturnValue_t checkSequence() const;
+	ReturnValue_t checkSequence() const override;
 
-	ReturnValue_t sleepFor(uint32_t ms);
+	ReturnValue_t sleepFor(uint32_t ms) override;
 
 protected:
 	bool started;

From f6d2549534e8c4baa59e718781d3384c1d7922eb Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:35:07 +0200
Subject: [PATCH 21/28] requested changed implemented

---
 container/HybridIterator.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index db1ce4bc..79f0485f 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -17,8 +17,8 @@ public:
 	}
 
 	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(
-					start->value), linked(true), end(NULL) {
+		LinkedElement<T>::Iterator(start), value(start->value),
+		linked(true) {
 
 	}
 
@@ -64,11 +64,11 @@ public:
 		return tmp;
 	}
 
-	bool operator==(const HybridIterator& other) {
+	bool operator==(const HybridIterator& other) const {
 		return value == other.value;
 	}
 
-	bool operator!=(const HybridIterator& other) {
+	bool operator!=(const HybridIterator& other) const {
 		return !(*this == other);
 	}
 

From a5a53e7f9b67bc6fd9e8df90f354a5502dace4df Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Wed, 24 Jun 2020 11:36:10 +0200
Subject: [PATCH 22/28] include guard updated

---
 container/HybridIterator.h | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 79f0485f..3dbd47a8 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -1,5 +1,5 @@
-#ifndef HYBRIDITERATOR_H_
-#define HYBRIDITERATOR_H_
+#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
+#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
 
 #include <framework/container/ArrayList.h>
 #include <framework/container/SinglyLinkedList.h>
@@ -24,16 +24,16 @@ public:
 
 	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
 			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value), linked(
-					false), end(end.value) {
+			ArrayList<T, count_t>::Iterator(start), value(start.value),
+			linked(false), end(end.value) {
 		if (value == this->end) {
 			value = NULL;
 		}
 	}
 
 	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement), linked(
-					false), end(++lastElement) {
+			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+			linked(false), end(++lastElement) {
 		if (value == end) {
 			value = NULL;
 		}
@@ -42,17 +42,17 @@ public:
 	HybridIterator& operator++() {
 		if (linked) {
 			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != NULL) {
+			if (LinkedElement<T>::Iterator::value != nullptr) {
 				value = LinkedElement<T>::Iterator::value->value;
 			} else {
-				value = NULL;
+				value = nullptr;
 			}
 		} else {
 			ArrayList<T, count_t>::Iterator::operator++();
 			value = ArrayList<T, count_t>::Iterator::value;
 
 			if (value == end) {
-				value = NULL;
+				value = nullptr;
 			}
 		}
 		return *this;

From 053b47215786d38b0f604755e0b712300908296a Mon Sep 17 00:00:00 2001
From: Steffen Gaisser <gaisser@irs.uni-stuttgart.de>
Date: Thu, 25 Jun 2020 18:09:32 +0200
Subject: [PATCH 23/28] Fixed spelling mistake in HealthHelper

---
 devicehandlers/ChildHandlerBase.cpp  | 2 +-
 devicehandlers/DeviceHandlerBase.cpp | 2 +-
 devicehandlers/HealthDevice.cpp      | 2 +-
 health/HealthHelper.cpp              | 4 ++--
 health/HealthHelper.h                | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/devicehandlers/ChildHandlerBase.cpp b/devicehandlers/ChildHandlerBase.cpp
index 50a5c07e..430b24e0 100644
--- a/devicehandlers/ChildHandlerBase.cpp
+++ b/devicehandlers/ChildHandlerBase.cpp
@@ -34,7 +34,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 		parent->registerChild(getObjectId());
 	}
 
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 
 	modeHelper.setParentQueue(parentQueue);
 
diff --git a/devicehandlers/DeviceHandlerBase.cpp b/devicehandlers/DeviceHandlerBase.cpp
index 90875838..2e24e0d5 100644
--- a/devicehandlers/DeviceHandlerBase.cpp
+++ b/devicehandlers/DeviceHandlerBase.cpp
@@ -1072,7 +1072,7 @@ ReturnValue_t DeviceHandlerBase::handleDeviceHandlerMessage(
 
 void DeviceHandlerBase::setParentQueue(MessageQueueId_t parentQueueId) {
 	modeHelper.setParentQueue(parentQueueId);
-	healthHelper.setParentQeueue(parentQueueId);
+	healthHelper.setParentQueue(parentQueueId);
 }
 
 bool DeviceHandlerBase::isAwaitingReply() {
diff --git a/devicehandlers/HealthDevice.cpp b/devicehandlers/HealthDevice.cpp
index ea0b99ff..61a82421 100644
--- a/devicehandlers/HealthDevice.cpp
+++ b/devicehandlers/HealthDevice.cpp
@@ -38,7 +38,7 @@ MessageQueueId_t HealthDevice::getCommandQueue() const {
 }
 
 void HealthDevice::setParentQueue(MessageQueueId_t parentQueue) {
-	healthHelper.setParentQeueue(parentQueue);
+	healthHelper.setParentQueue(parentQueue);
 }
 
 bool HealthDevice::hasHealthChanged() {
diff --git a/health/HealthHelper.cpp b/health/HealthHelper.cpp
index ed97f3d3..7b8b3a53 100644
--- a/health/HealthHelper.cpp
+++ b/health/HealthHelper.cpp
@@ -29,11 +29,11 @@ HasHealthIF::HealthState HealthHelper::getHealth() {
 }
 
 ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
-	setParentQeueue(parentQueue);
+	setParentQueue(parentQueue);
 	return initialize();
 }
 
-void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
+void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
 	this->parentQueue = parentQueue;
 }
 
diff --git a/health/HealthHelper.h b/health/HealthHelper.h
index a1ca2c52..471bc7e9 100644
--- a/health/HealthHelper.h
+++ b/health/HealthHelper.h
@@ -78,7 +78,7 @@ public:
 	/**
 	 * @param parentQueue the Queue id of the parent object. Set to 0 if no parent present
 	 */
-	void setParentQeueue(MessageQueueId_t parentQueue);
+	void setParentQueue(MessageQueueId_t parentQueue);
 
 	/**
 	 *

From bfd49caab4dd4432a575cc13738a818167d62c43 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Fri, 26 Jun 2020 12:52:03 +0200
Subject: [PATCH 24/28] fixed include guard comment

---
 container/HybridIterator.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 3dbd47a8..f2fd6b28 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -87,4 +87,4 @@ private:
 	T *end = nullptr;
 };
 
-#endif /* HYBRIDITERATOR_H_ */
+#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

From 6a0a2675b1bba3f69e81224d935ac93166306c97 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Mon, 6 Jul 2020 12:36:01 +0200
Subject: [PATCH 25/28] typedef instead of auto used now

---
 osal/FreeRTOS/FixedTimeslotTask.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/osal/FreeRTOS/FixedTimeslotTask.cpp b/osal/FreeRTOS/FixedTimeslotTask.cpp
index 223cf4bd..c062101d 100644
--- a/osal/FreeRTOS/FixedTimeslotTask.cpp
+++ b/osal/FreeRTOS/FixedTimeslotTask.cpp
@@ -82,10 +82,10 @@ ReturnValue_t FixedTimeslotTask::checkSequence() const {
 void FixedTimeslotTask::taskFunctionality() {
 	// A local iterator for the Polling Sequence Table is created to find the
     // start time for the first entry.
-	auto slotListIter = pst.current;
+	FixedSlotSequence::SlotListIter slotListIter = pst.current;
 
 	//The start time for the first entry is read.
-	uint32_t intervalMs = (*slotListIter)->pollingTimeMs;
+	uint32_t intervalMs = slotListIter->pollingTimeMs;
 	TickType_t interval = pdMS_TO_TICKS(intervalMs);
 
 	TickType_t xLastWakeTime;

From 133ed9586b2ecceccdf92316f25d7cbf2c551c0d Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 19:31:28 +0200
Subject: [PATCH 26/28] tmtc bridge improvements

---
 tmtcservices/TmTcBridge.cpp | 58 +++++++++++++++++++++++--------------
 tmtcservices/TmTcBridge.h   | 53 +++++++++++++++++----------------
 2 files changed, 63 insertions(+), 48 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index f9a7d3bc..8c44f7de 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -5,11 +5,13 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 #include <framework/globalfunctions/arrayprinter.h>
 
-TmTcBridge::TmTcBridge(object_id_t objectId_,
-        object_id_t ccsdsPacketDistributor_): SystemObject(objectId_),
-        ccsdsPacketDistributor(ccsdsPacketDistributor_)
+TmTcBridge::TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+		object_id_t tmStoreId, object_id_t tcStoreId):
+		SystemObject(objectId),tmStoreId(tmStoreId), tcStoreId(tcStoreId),
+		tcDestination(tcDestination)
+
 {
-    TmTcReceptionQueue = QueueFactory::instance()->
+    tmTcReceptionQueue = QueueFactory::instance()->
             createMessageQueue(TMTC_RECEPTION_QUEUE_DEPTH);
 }
 
@@ -42,20 +44,27 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 }
 
 ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
-	if (tcStore == NULL) {
-		return RETURN_FAILED;
+	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	if (tcStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-	tmStore = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-	if (tmStore == NULL) {
-		return RETURN_FAILED;
+	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	if (tmStore == nullptr) {
+		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
+				"it is created and set up properly." << std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(ccsdsPacketDistributor);
-	if (tcDistributor == NULL) {
-		return RETURN_FAILED;
+			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	if (tcDistributor == nullptr) {
+		sif::error << "TmTcBridge::initialize: TC Distributor invalid"
+				<< std::endl;
+		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-	TmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
+
+	tmTcReceptionQueue->setDefaultDestination(tcDistributor->getRequestQueue());
 	return RETURN_OK;
 }
 
@@ -73,10 +82,7 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 }
 
 ReturnValue_t TmTcBridge::handleTc() {
-	uint8_t * recvBuffer = nullptr;
-	size_t recvLen = 0;
-	ReturnValue_t result = receiveTc(&recvBuffer, &recvLen);
-	return result;
+	return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t TmTcBridge::handleTm() {
@@ -97,8 +103,8 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 	TmTcMessage message;
 	const uint8_t* data = nullptr;
 	size_t size = 0;
-	for (ReturnValue_t result = TmTcReceptionQueue->receiveMessage(&message);
-		 result == RETURN_OK; result = TmTcReceptionQueue->receiveMessage(&message))
+	for (ReturnValue_t result = tmTcReceptionQueue->receiveMessage(&message);
+		 result == RETURN_OK; result = tmTcReceptionQueue->receiveMessage(&message))
 	{
 		if(communicationLinkUp == false) {
 			result = storeDownlinkData(&message);
@@ -183,10 +189,20 @@ void TmTcBridge::registerCommDisconnect() {
 }
 
 MessageQueueId_t TmTcBridge::getReportReceptionQueue(uint8_t virtualChannel) {
-	return TmTcReceptionQueue->getId();
+	return tmTcReceptionQueue->getId();
 }
 
 
 void TmTcBridge::printData(uint8_t * data, size_t dataLen) {
 	arrayprinter::print(data, dataLen);
 }
+
+uint16_t TmTcBridge::getIdentifier() {
+	// This is no PUS service, so we just return 0
+	return 0;
+}
+
+MessageQueueId_t TmTcBridge::getRequestQueue() {
+	// Default implementation: Relay TC messages to TC distributor directly.
+	return tmTcReceptionQueue->getDefaultDestination();
+}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e0432d8..3e3d1b71 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -1,16 +1,18 @@
 #ifndef FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 #define FRAMEWORK_TMTCSERVICES_TMTCBRIDGE_H_
 
+#include <framework/objectmanager/SystemObject.h>
 #include <framework/tmtcservices/AcceptsTelemetryIF.h>
 #include <framework/tasks/ExecutableObjectIF.h>
 #include <framework/ipc/MessageQueueIF.h>
 #include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/objectmanager/SystemObject.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
 
-#include <framework/tmtcservices/TmTcMessage.h>
 #include <framework/container/FIFO.h>
+#include <framework/tmtcservices/TmTcMessage.h>
 
 class TmTcBridge : public AcceptsTelemetryIF,
+		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF,
 		public SystemObject {
@@ -22,7 +24,8 @@ public:
 	static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
 	static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;
 
-	TmTcBridge(object_id_t objectId_, object_id_t ccsdsPacketDistributor_);
+	TmTcBridge(object_id_t objectId, object_id_t tcDestination,
+			object_id_t tmStoreId, object_id_t tcStoreId);
 	virtual ~TmTcBridge();
 
 	/**
@@ -57,45 +60,41 @@ public:
 	 */
 	virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-	/**
-	 * Return TMTC Reception Queue
-	 * @param virtualChannel
-	 * @return
-	 */
-	MessageQueueId_t getReportReceptionQueue(
+
+	/** AcceptsTelemetryIF override */
+	virtual MessageQueueId_t getReportReceptionQueue(
 			uint8_t virtualChannel = 0) override;
+
+	/** AcceptsTelecommandsIF override */
+	virtual uint16_t getIdentifier() override;
+	virtual MessageQueueId_t getRequestQueue() override;
+
 protected:
+	//! Cached for initialize function.
+	object_id_t tmStoreId = objects::NO_OBJECT;
+	object_id_t tcStoreId = objects::NO_OBJECT;
+	object_id_t tcDestination = objects::NO_OBJECT;
+
 	//! Used to send and receive TMTC messages.
 	//! TmTcMessage is used to transport messages between tasks.
-	MessageQueueIF* TmTcReceptionQueue = nullptr;
-	StorageManagerIF* tcStore = nullptr;
+	MessageQueueIF* tmTcReceptionQueue = nullptr;
+
 	StorageManagerIF* tmStore = nullptr;
-	object_id_t ccsdsPacketDistributor = 0;
-	//! Used to specify whether communication link is up
-	bool communicationLinkUp = false;
+	StorageManagerIF* tcStore = nullptr;
+
+	//! Used to specify whether communication link is up by default.
+	bool communicationLinkUp = true;
 	bool tmStored = false;
 
 	/**
 	 * @brief 	Handle TC reception
 	 * @details
 	 * Default implementation provided, but is empty.
-	 * Child handler should override this in most cases orsend TC to the
-	 * TC distributor directly with the address of the reception queue by
-	 * calling getReportRecptionQueue()
+	 * In most cases, TC reception will be handled in a separate task anyway.
 	 * @return
 	 */
 	virtual ReturnValue_t handleTc();
 
-	/**
-	 * Implemented by child class. Perform receiving of Telecommand,
-	 * for example by implementing specific drivers or wrappers,
-	 * e.g. UART Communication or an ethernet stack
-	 * @param recvBuffer [out] Received data
-	 * @param size [out] Size of received data
-	 * @return
-	 */
-	virtual ReturnValue_t receiveTc(uint8_t ** recvBuffer, size_t * size) = 0;
-
 	/**
 	 * Handle Telemetry. Default implementation provided.
 	 * Calls sendTm()

From 90e299977bcb0d32672d520ecf94fee666913923 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 19:41:16 +0200
Subject: [PATCH 27/28] minor formatting improvements

---
 tmtcservices/TmTcBridge.cpp | 27 +++++++++++++++------------
 tmtcservices/TmTcBridge.h   | 11 +++++++----
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/tmtcservices/TmTcBridge.cpp b/tmtcservices/TmTcBridge.cpp
index 8c44f7de..b55803cb 100644
--- a/tmtcservices/TmTcBridge.cpp
+++ b/tmtcservices/TmTcBridge.cpp
@@ -24,8 +24,9 @@ ReturnValue_t TmTcBridge::setNumberOfSentPacketsPerCycle(
 		return RETURN_OK;
 	}
 	else {
-	    sif::warning << "TmTcBridge: Number of packets sent per cycle "
-	               "exceeds limits. Keeping default value." << std::endl;
+	    sif::warning << "TmTcBridge::setNumberOfSentPacketsPerCycle: Number of "
+	             << "packets sent per cycle exceeds limits. "
+	             << "Keeping default value." << std::endl;
 		return RETURN_FAILED;
 	}
 }
@@ -37,8 +38,9 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
         return RETURN_OK;
     }
     else {
-        sif::warning << "TmTcBridge: Number of packets stored "
-                   "exceeds limits. Keeping default value." << std::endl;
+        sif::warning << "TmTcBridge::setMaxNumberOfPacketsStored: Number of "
+                << "packets stored exceeds limits. "
+                << "Keeping default value." << std::endl;
         return RETURN_FAILED;
     }
 }
@@ -72,11 +74,13 @@ ReturnValue_t TmTcBridge::performOperation(uint8_t operationCode) {
 	ReturnValue_t result;
 	result = handleTc();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TCs" << std::endl;
+		sif::debug << "TmTcBridge::performOperation: "
+		        << "Error handling TCs" << std::endl;
 	}
 	result = handleTm();
 	if (result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Error handling TMs" << std::endl;
+	    sif::debug << "TmTcBridge::performOperation: "
+	                    << "Error handling TMs" << std::endl;
 	}
 	return result;
 }
@@ -88,7 +92,7 @@ ReturnValue_t TmTcBridge::handleTc() {
 ReturnValue_t TmTcBridge::handleTm() {
 	ReturnValue_t result = handleTmQueue();
 	if(result != RETURN_OK) {
-		sif::error << "TMTC Bridge: Reading TM Queue failed" << std::endl;
+		sif::warning << "TmTcBridge: Reading TM Queue failed" << std::endl;
 		return RETURN_FAILED;
 	}
 
@@ -118,7 +122,7 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 
 		result = sendTm(data, size);
 		if (result != RETURN_OK) {
-			sif::error << "TMTC Bridge: Could not send TM packet"<< std::endl;
+			sif::warning << "TmTcBridge: Could not send TM packet" << std::endl;
 			tmStore->deleteData(message.getStorageId());
 			return result;
 
@@ -129,13 +133,12 @@ ReturnValue_t TmTcBridge::handleTmQueue() {
 }
 
 ReturnValue_t TmTcBridge::storeDownlinkData(TmTcMessage *message) {
-	//debug << "TMTC Bridge: Comm Link down. "
-	//		 "Saving packet ID to be sent later\r\n" << std::flush;
 	store_address_t storeId = 0;
 
 	if(tmFifo.full()) {
-		sif::error << "TMTC Bridge: TM downlink max. number of stored packet IDs "
-				 "reached! Overwriting old data" << std::endl;
+		sif::error << "TmTcBridge::storeDownlinkData: TM downlink max. number "
+		        << "of stored packet IDs reached! "
+		        << "Overwriting old data" << std::endl;
 		tmFifo.retrieve(&storeId);
 		tmStore->deleteData(storeId);
 	}
diff --git a/tmtcservices/TmTcBridge.h b/tmtcservices/TmTcBridge.h
index 3e3d1b71..993cd5b9 100644
--- a/tmtcservices/TmTcBridge.h
+++ b/tmtcservices/TmTcBridge.h
@@ -76,13 +76,14 @@ protected:
 	object_id_t tcDestination = objects::NO_OBJECT;
 
 	//! Used to send and receive TMTC messages.
-	//! TmTcMessage is used to transport messages between tasks.
+	//! The TmTcMessage class is used to transport messages between tasks.
 	MessageQueueIF* tmTcReceptionQueue = nullptr;
 
 	StorageManagerIF* tmStore = nullptr;
 	StorageManagerIF* tcStore = nullptr;
 
-	//! Used to specify whether communication link is up by default.
+	//! Used to specify whether communication link is up. Will be true
+	//! by default, so telemetry will be handled immediately.
 	bool communicationLinkUp = true;
 	bool tmStored = false;
 
@@ -103,7 +104,8 @@ protected:
 	virtual ReturnValue_t handleTm();
 
 	/**
-	 * Read the TM Queue and send TM if necessary. Default implementation provided
+	 * Read the TM Queue and send TM if necessary.
+	 * Default implementation provided
 	 * @return
 	 */
 	virtual ReturnValue_t handleTmQueue();
@@ -116,7 +118,8 @@ protected:
 
 	/**
 	 * Implemented by child class. Perform sending of Telemetry by implementing
-	 * communication drivers or wrappers, e.g. UART communication or lwIP stack.
+	 * communication drivers or wrappers, e.g. serial communication or a socket
+	 * call.
 	 * @param data
 	 * @param dataLen
 	 * @return

From d1e922eecf6b24bdd01286864a075b63080d4aa0 Mon Sep 17 00:00:00 2001
From: "Robin.Mueller" <robin.mueller.m@gmail.com>
Date: Thu, 9 Jul 2020 20:08:40 +0200
Subject: [PATCH 28/28] new intiialize after task creation function

---
 tasks/ExecutableObjectIF.h | 36 ++++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/tasks/ExecutableObjectIF.h b/tasks/ExecutableObjectIF.h
index 5c5955c1..d716cdfb 100644
--- a/tasks/ExecutableObjectIF.h
+++ b/tasks/ExecutableObjectIF.h
@@ -1,15 +1,5 @@
-/**
- * @file	ExecutableObjectIF.h
- *
- * @brief	This file contains the definition for the ExecutableObjectIF interface.
- *
- * @author	Bastian Baetz
- *
- * @date	12.03.2012
- */
-
-#ifndef EXECUTABLEOBJECTIF_H_
-#define EXECUTABLEOBJECTIF_H_
+#ifndef FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
+#define FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_
 
 class PeriodicTaskIF;
 
@@ -20,6 +10,7 @@ class PeriodicTaskIF;
  * @brief	The interface provides a method to execute objects within a task.
  * @details	The performOperation method, that is required by the interface is
  * 			executed cyclically within a task context.
+ * @author  Bastian Baetz
  */
 class ExecutableObjectIF {
 public:
@@ -37,13 +28,26 @@ public:
 
 	/**
 	 * @brief Function called during setup assignment of object to task
-	 * @details Has to be called from the function that assigns the object to a task and
-	 * 			enables the object implementation to overwrite this function and get a reference to the executing task
+	 * @details
+	 * Has to be called from the function that assigns the object to a task and
+	 * enables the object implementation to overwrite this function and get
+	 * a reference to the executing task
 	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task_) {
+	virtual void setTaskIF(PeriodicTaskIF* task_) {};
 
+	/**
+	 * This function should be called after the object was assigned to a
+	 * specific task.
+	 *
+	 * Example: Can be used to get task execution frequency.
+	 * The task is created after initialize() and the object ctors have been
+	 * called so the execution frequency can't be cached in initialize()
+	 * @return
+	 */
+	virtual ReturnValue_t initializeAfterTaskCreation() {
+	    return HasReturnvaluesIF::RETURN_OK;
 	}
 };
 
-#endif /* EXECUTABLEOBJECTIF_H_ */
+#endif /* FRAMEWORK_TASKS_EXECUTABLEOBJECTIF_H_ */