Merge remote-tracking branch 'upstream/master' into mueller/file_renormalization

container/RingBufferBase.h

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

container/SharedRingBuffer.cpp

@@ -0,0 +1,30 @@
+#include "SharedRingBuffer.h"
+#include "../ipc/MutexFactory.h"
+#include "../ipc/MutexHelper.h"
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
+		bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
+		const size_t size, bool overwriteOld, size_t maxExcessBytes):
+		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+		maxExcessBytes) {
+	mutex = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
+        MutexIF::TimeoutType timeoutType, dur_millis_t timeout) {
+    return mutex->lockMutex(timeoutType, timeout);
+}
+
+ReturnValue_t SharedRingBuffer::unlockRingBufferMutex() {
+    return mutex->unlockMutex();
+}
+
+MutexIF* SharedRingBuffer::getMutexHandle() const {
+    return mutex;
+}

container/SharedRingBuffer.h

@@ -0,0 +1,68 @@
+#ifndef FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+#define FSFW_CONTAINER_SHAREDRINGBUFFER_H_
+
+#include "SimpleRingBuffer.h"
+#include "../ipc/MutexIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../timemanager/Clock.h"
+
+/**
+ * @brief   Ring buffer which can be shared among multiple objects
+ * @details
+ * This class offers a mutex to perform thread-safe operation on the ring
+ * buffer. It is still up to the developer to actually perform the lock
+ * and unlock operations.
+ */
+class SharedRingBuffer: public SystemObject,
+		public SimpleRingBuffer {
+public:
+	/**
+	 * This constructor allocates a new internal buffer with the supplied size.
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * This constructor takes an external buffer with the specified size.
+	 * @param buffer
+	 * @param size
+	 * @param overwriteOld
+	 * If the ring buffer is overflowing at a write operartion, the oldest data
+	 * will be overwritten.
+	 */
+	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+			bool overwriteOld, size_t maxExcessBytes);
+
+	/**
+	 * Unless a read-only constant value is read, all operations on the
+	 * shared ring buffer should be protected by calling this function.
+	 * @param timeoutType
+	 * @param timeout
+	 * @return
+	 */
+	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+	        dur_millis_t timeout);
+	/**
+	 * Any locked mutex also has to be unlocked, otherwise, access to the
+	 * shared ring buffer will be blocked.
+	 * @return
+	 */
+	virtual ReturnValue_t unlockRingBufferMutex();
+
+	/**
+	 * The mutex handle can be accessed directly, for example to perform
+	 * the lock with the #MutexHelper for a RAII compliant lock operation.
+	 * @return
+	 */
+	MutexIF* getMutexHandle() const;
+private:
+	MutexIF* mutex = nullptr;
+};
+
+
+
+#endif /* FSFW_CONTAINER_SHAREDRINGBUFFER_H_ */

container/SimpleRingBuffer.cpp

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

container/SimpleRingBuffer.h

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

events/fwSubsystemIdRanges.h

@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#ifndef FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
-#define FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_
+#define FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_
 
 namespace SUBSYSTEM_ID {
 enum {
@@ -19,10 +19,11 @@ enum {
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
 	PUS_SERVICE_1 = 80,
+	PUS_SERVICE_17 = 97,
 	FW_SUBSYSTEM_ID_RANGE
 };
 }
 
 
 
-#endif /* FRAMEWORK_EVENTS_FWSUBSYSTEMIDRANGES_H_ */
+#endif /* FSFW_EVENTS_FWSUBSYSTEMIDRANGES_H_ */

objectmanager/ObjectManager.h

@@ -1,12 +1,5 @@
-/**
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
- * @file	ObjectManager.h
+#define FSFW_OBJECTMANAGER_OBJECTMANAGER_H_
- * @brief	This file contains the implementation of the ObjectManager class
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef OBJECTMANAGER_H_
-#define OBJECTMANAGER_H_
 
 #include "ObjectManagerIF.h"
 #include "SystemObjectIF.h"
@@ -22,14 +15,15 @@
  * 			most of the system initialization.
  * 			As the system is static after initialization, no new objects are
  * 			created or inserted into the list after startup.
- * \ingroup system_objects
+ * @ingroup system_objects
+ * @author	Bastian Baetz
  */
 class ObjectManager : public ObjectManagerIF {
 private:
 	//comparison?
 	/**
-	 * \brief	This is the map of all initialized objects in the manager.
+	 * @brief	This is the map of all initialized objects in the manager.
-	 * \details	Objects in the List must inherit the SystemObjectIF.
+	 * @details	Objects in the List must inherit the SystemObjectIF.
 	 */
 	std::map<object_id_t, SystemObjectIF*> objectList;
 protected:
@@ -54,7 +48,8 @@ public:
 	/**
 	 *	@brief	In the class's destructor, all objects in the list are deleted.
 	 */
-	//SHOULDDO: If, for some reason, deleting an ObjectManager instance is required, check if this works.
+	// SHOULDDO: If, for some reason, deleting an ObjectManager instance is
+	// required, check if this works.
 	virtual ~ObjectManager( void );
 	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
 	ReturnValue_t remove( object_id_t id );
@@ -64,4 +59,4 @@ public:
 
 
 
-#endif /* OBJECTMANAGER_H_ */
+#endif /* FSFW_OBJECTMANAGER_OBJECTMANAGER_H_ */

objectmanager/ObjectManagerIF.h

@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#ifndef FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
-#define FRAMEWORK_OBJECTMANAGER_OBJECTMANAGERIF_H_
+#define FSFW_OBJECTMANAGER_OBJECTMANAGERIF_H_
 
 #include "frameworkObjects.h"
 #include "SystemObjectIF.h"
@@ -21,7 +21,6 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
 	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
 	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-
 	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 ); //!< Can be used if the initialization of a SystemObject failed.
 	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
 
@@ -80,6 +79,7 @@ public:
 /**
  * @brief	This is the forward declaration of the global objectManager instance.
  */
+// SHOULDDO: maybe put this in the glob namespace to explicitely mark it global?
 extern ObjectManagerIF *objectManager;
 
 /*Documentation can be found in the class method declaration above.*/

objectmanager/SystemObject.cpp

@@ -1,6 +1,6 @@
-#include "../events/EventManagerIF.h"
 #include "ObjectManager.h"
 #include "SystemObject.h"
+#include "../events/EventManagerIF.h"
 
 SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
 		objectId(setObjectId), registered(doRegister) {

objectmanager/SystemObject.h

@@ -1,16 +1,9 @@
-/**
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
- * @file	SystemObject.h
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_
- * @brief	This file contains the definition of the SystemObject class.
- * @date	07.11.2012
- * @author	Ulrich Mohr
- */
-
-#ifndef SYSTEMOBJECT_H_
-#define SYSTEMOBJECT_H_
 
+#include "SystemObjectIF.h"
 #include "../events/Event.h"
 #include "../events/EventReportingProxyIF.h"
-#include "SystemObjectIF.h"
 #include "../timemanager/Clock.h"
 
 /**
@@ -20,7 +13,8 @@
  * 			class that is announced to ObjectManager. It automatically includes
  * 			itself (and therefore the inheriting class) in the object manager's
  * 			list.
- * \ingroup system_objects
+ * @author	Ulrich Mohr
+ * @ingroup system_objects
  */
 class SystemObject: public SystemObjectIF {
 private:
@@ -37,25 +31,28 @@ public:
 	 * @param parameter1
 	 * @param parameter2
 	 */
-	virtual void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0);
+	virtual void triggerEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0);
 
 	/**
 	 * @brief	The class's constructor.
 	 * @details	In the constructor, the object id is set and the class is
 	 * 			inserted in the object manager.
 	 * @param setObjectId	The id the object shall have.
-	 * @param doRegister	Determines if the object is registered in the global object manager.
+	 * @param doRegister	Determines if the object is registered in
+	 * 						the global object manager.
 	 */
 	SystemObject(object_id_t setObjectId, bool doRegister = true);
 	/**
 	 * @brief	On destruction, the object removes itself from the list.
 	 */
 	virtual ~SystemObject();
-	object_id_t getObjectId() const;
+	object_id_t getObjectId() const override;
-	virtual ReturnValue_t initialize();
+	virtual ReturnValue_t initialize() override;
 	virtual ReturnValue_t checkObjectConnections();
 
-	virtual void forwardEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) const;
+	virtual void forwardEvent(Event event, uint32_t parameter1 = 0,
+			uint32_t parameter2 = 0) const;
 };
 
-#endif /* SYSTEMOBJECT_H_ */
+#endif /* FSFW_OBJECTMANAGER_SYSTEMOBJECT_H_ */

objectmanager/SystemObjectIF.h

@@ -1,26 +1,19 @@
-/**
+#ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
- * @file	SystemObjectIF.h
+#define FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_
- * @brief	This file contains the definition of the SystemObjectIF interface.
- * @date	18.09.2012
- * @author	Bastian Baetz
- */
-
-#ifndef SYSTEMOBJECTIF_H_
-#define SYSTEMOBJECTIF_H_
 
 #include "../events/EventReportingProxyIF.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include <stdint.h>
+#include <cstdint>
 /**
- * \defgroup system_objects Software System Object Management
+ * @defgroup system_objects Software System Object Management
- * The classes to create System Objects and classes to manage these are contained in this group.
+ * The classes to create System Objects and classes to manage these are
- * System Objects are software elements that can be controlled externally. They all have a unique
+ * contained in this group. System Objects are software elements that can be
- * object identifier.
+ * controlled externally. They all have a unique object identifier.
  */
 
 /**
  * This is the typedef for object identifiers.
- * \ingroup system_objects
+ * @ingroup system_objects
  */
 typedef uint32_t object_id_t;
 
@@ -29,7 +22,8 @@ typedef uint32_t object_id_t;
  * list.
  * It does not provide any method definitions, still it is required to
  * perform a type check with dynamic_cast.
- * \ingroup system_objects
+ * @author  Bastian Baetz
+ * @ingroup system_objects
  */
 class SystemObjectIF : public EventReportingProxyIF {
 public:
@@ -41,24 +35,28 @@ public:
 	/**
 	 * The empty virtual destructor as required for C++ interfaces.
 	 */
-	virtual ~SystemObjectIF() {
+	virtual ~SystemObjectIF() {}
-	}
 	/**
-	 * Initializes all inter-object dependencies.
+	 * @brief   Initializes the object.
-	 * This is necessary to avoid circular dependencies of not-fully
+	 * There are initialization steps which can also be done in the constructor.
-	 * initialized objects on start up.
+	 * However, there is no clean way to get a returnvalue from a constructor.
-	 * @return	- \c RETURN_OK in case the initialization was successful
+	 * Furthermore some components require other system object to be created
-	 * 			- \c RETURN_FAILED otherwise
+	 * which might not have been built yet.
+	 * Therefore, a two-step initialization resolves this problem and prevents
+	 * circular dependencies of not-fully initialized objects on start up.
+	 * @return	- @c RETURN_OK in case the initialization was successful
+	 * 			- @c RETURN_FAILED otherwise
 	 */
 	virtual ReturnValue_t initialize() = 0;
 	/**
-	 * Checks, if all object-object interconnections are satisfying for operation.
+	 * @brief   Checks if all object-object interconnections are satisfying
-	 * Some objects need certain other objects (or a certain number), to be registered as children.
+	 *          for operation.
-	 * These checks can be done in this method.
+	 * Some objects need certain other objects (or a certain number), to be
-	 * @return	- \c RETURN_OK in case the check was successful
+	 * registered as children. These checks can be done in this method.
-	 * 			- \c any other code otherwise
+	 * @return	- @c RETURN_OK in case the check was successful
+	 * 			- @c any other code otherwise
 	 */
 	virtual ReturnValue_t checkObjectConnections() = 0;
 };
 
-#endif /* SYSTEMOBJECTIF_H_ */
+#endif /* #ifndef FSFW_OBJECTMANAGER_SYSTEMOBJECTIF_H_ */

objectmanager/frameworkObjects.h

@@ -1,8 +1,15 @@
-#ifndef FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#ifndef FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
-#define FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
+#define FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_
 
 namespace objects {
 enum framework_objects {
+	// Default verification reporter.
+	PUS_SERVICE_1 = 0x53000001,
+	PUS_SERVICE_2 = 0x53000002,
+	PUS_SERVICE_5 = 0x53000005,
+	PUS_SERVICE_8 = 0x53000008,
+	PUS_SERVICE_200 = 0x53000200,
+
 	//Generic IDs for IPC, modes, health, events
 	HEALTH_TABLE = 0x53010000,
 //	MODE_STORE = 0x53010100,
@@ -12,10 +19,11 @@ enum framework_objects {
 	//IDs for PUS Packet Communication
 	TC_STORE = 0x534f0100,
 	TM_STORE = 0x534f0200,
+
 	NO_OBJECT = 0xFFFFFFFF
 };
 }
 
 
 
-#endif /* FRAMEWORK_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */
+#endif /* FSFW_OBJECTMANAGER_FRAMEWORKOBJECTS_H_ */

osal/linux/Clock.cpp

@@ -75,24 +75,25 @@ timeval Clock::getUptime() {
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
+    //TODO This is not posix compatible and delivers only seconds precision
+    // is the OS not called Linux?
+    //Linux specific file read but more precise
+    double uptimeSeconds;
+    if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
+        uptime->tv_sec = uptimeSeconds;
+        uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
+    }
+
 	//TODO This is not posix compatible and delivers only seconds precision
-	struct sysinfo sysInfo;
+    // I suggest this is moved into another clock function which will
-	int result = sysinfo(&sysInfo);
+    // deliver second precision later.
-	if(result != 0){
+//	struct sysinfo sysInfo;
-		return HasReturnvaluesIF::RETURN_FAILED;
+//	int result = sysinfo(&sysInfo);
-	}
+//	if(result != 0){
-	uptime->tv_sec = sysInfo.uptime;
+//		return HasReturnvaluesIF::RETURN_FAILED;
-	uptime->tv_usec = 0;
-
-
-	//Linux specific file read but more precise
-//	double uptimeSeconds;
-//	if(std::ifstream("/proc/uptime",std::ios::in) >> uptimeSeconds){
-//		uptime->tv_sec = uptimeSeconds;
-//		uptime->tv_usec = uptimeSeconds *(double) 1e6 - (uptime->tv_sec *1e6);
 //	}
-
+//	return sysInfo.uptime;
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {

pus/Service17Test.cpp

@@ -0,0 +1,41 @@
+#include "Service17Test.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/SystemObject.h"
+#include "../tmtcpacket/pus/TmPacketStored.h"
+
+
+Service17Test::Service17Test(object_id_t objectId,
+        uint16_t apid, uint8_t serviceId):
+    PusServiceBase(objectId, apid, serviceId),
+    packetSubCounter(0) {
+}
+
+Service17Test::~Service17Test() {
+}
+
+ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
+	switch(subservice){
+	case Subservice::CONNECTION_TEST: {
+		TmPacketStored connectionPacket(apid, serviceId,
+		        Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+		connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+				requestQueue->getId());
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+    case Subservice::EVENT_TRIGGER_TEST: {
+        TmPacketStored connectionPacket(apid, serviceId,
+                Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
+        connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
+                requestQueue->getId());
+        triggerEvent(TEST, 1234, 5678);
+        return RETURN_OK;
+    }
+	default:
+		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+	}
+}
+
+ReturnValue_t Service17Test::performService() {
+	return HasReturnvaluesIF::RETURN_OK;
+}

pus/Service17Test.h

@@ -0,0 +1,44 @@
+#ifndef FSFW_PUS_SERVICE17TEST_H_
+#define FSFW_PUS_SERVICE17TEST_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief Test Service
+ * Full Documentation: ECSS-E70-41A p.167
+ *
+ * The test service provides the capability to activate test functions
+ * implemented on-board and to report the results of such tests.
+ * Service capability:
+ *   - TC[17,1]: Perform connection test
+ *   - TM[17,2]: Send Connection Test Report
+ *   - TC[17,128]: Perform connection test and trigger event
+ *
+ * @ingroup pus_services
+ */
+class Service17Test: public PusServiceBase {
+public:
+	// Custom events which can be triggered
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_17;
+	static constexpr Event TEST = MAKE_EVENT(0, SEVERITY::INFO);
+
+	enum Subservice: uint8_t {
+		//! [EXPORT] : [COMMAND] Perform connection test
+	    CONNECTION_TEST = 1,
+	    //! [EXPORT] : [REPLY] Connection test reply
+	    CONNECTION_TEST_REPORT = 2,
+		//!  [EXPORT] : [COMMAND] Trigger test reply and test event
+	    EVENT_TRIGGER_TEST = 128,
+	};
+
+	Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+	virtual ~Service17Test();
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+	virtual ReturnValue_t performService() override;
+
+protected:
+	uint16_t packetSubCounter = 0;
+};
+
+#endif /* FSFW_PUS_SERVICE17TEST_H_ */

pus/Service9TimeManagement.cpp

@@ -0,0 +1,58 @@
+#include "Service9TimeManagement.h"
+#include "servicepackets/Service9Packets.h"
+
+#include "../timemanager/CCSDSTime.h"
+#include "../events/EventManagerIF.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+
+
+Service9TimeManagement::Service9TimeManagement(object_id_t objectId,
+		uint16_t apid, uint8_t serviceId) :
+	PusServiceBase(objectId, apid , serviceId) {
+}
+
+Service9TimeManagement::~Service9TimeManagement() {}
+
+ReturnValue_t Service9TimeManagement::performService() {
+	return RETURN_OK;
+}
+
+ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
+	switch(subservice){
+		case SUBSERVICE::SET_TIME:{
+			return setTime();
+		}
+		default:
+			return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
+		}
+}
+
+ReturnValue_t Service9TimeManagement::setTime() {
+	Clock::TimeOfDay_t timeToSet;
+	TimePacket timePacket(currentPacket.getApplicationData(),
+			currentPacket.getApplicationDataSize());
+	ReturnValue_t result = CCSDSTime::convertFromCcsds(&timeToSet,
+			timePacket.getTime(), timePacket.getTimeSize());
+	if(result != RETURN_OK) {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return result;
+	}
+
+	uint32_t formerUptime;
+	Clock::getUptime(&formerUptime);
+	result = Clock::setClock(&timeToSet);
+
+	if(result == RETURN_OK) {
+		uint32_t newUptime;
+		Clock::getUptime(&newUptime);
+		triggerEvent(CLOCK_SET,newUptime,formerUptime);
+		return RETURN_OK;
+	}
+	else {
+		triggerEvent(CLOCK_SET_FAILURE, result, 0);
+		return RETURN_FAILED;
+	}
+}
+
+
+

pus/Service9TimeManagement.h

@@ -0,0 +1,41 @@
+#ifndef FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+#define FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_
+
+#include "../tmtcservices/PusServiceBase.h"
+
+class Service9TimeManagement: public PusServiceBase {
+public:
+
+	static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_9;
+	static constexpr Event CLOCK_SET = MAKE_EVENT(0, SEVERITY::INFO); //!< Clock has been set. P1: New Uptime. P2: Old Uptime
+	static constexpr Event CLOCK_SET_FAILURE = MAKE_EVENT(1, SEVERITY::LOW); //!< Clock could not be set. P1: Returncode.
+
+	static constexpr uint8_t CLASS_ID = CLASS_ID::PUS_SERVICE_9;
+
+	/**
+	 * 	@brief This service provides the capability to set the on-board time.
+	 */
+	Service9TimeManagement(object_id_t objectId, uint16_t apid,
+			uint8_t serviceId);
+
+	virtual ~Service9TimeManagement();
+
+	virtual ReturnValue_t performService() override;
+
+	/**
+	 * 	@brief Sets the onboard-time by retrieving the time to set from TC[9,128].
+	 */
+	virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+
+	virtual ReturnValue_t setTime();
+private:
+
+	enum SUBSERVICE {
+		SET_TIME = 128 //!< [EXPORT] : [COMMAND] Time command in ASCII, CUC or CDS format
+	};
+
+};
+
+
+
+#endif /* FSFW_PUS_SERVICE9TIMEMANAGEMENT_H_ */

pus/servicepackets/Service9Packets.h

@@ -0,0 +1,32 @@
+#ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+#define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
+
+#include "../../serialize/SerialLinkedListAdapter.h"
+
+/**
+ * @brief Subservice 128
+ * @details
+ * It only contains the time encoded as ASCII, CRC, CUC or CDS
+ * @ingroup spacepackets
+ */
+class TimePacket : SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
+public:
+	TimePacket(const uint8_t * timeBuffer_, uint32_t timeSize_) {
+		timeBuffer = timeBuffer_;
+		timeSize = timeSize_;
+	}
+	const uint8_t*  getTime() {
+		return timeBuffer;
+	}
+
+	uint32_t getTimeSize() const {
+		return timeSize;
+	}
+
+private:
+	TimePacket(const TimePacket &command);
+	const uint8_t * timeBuffer;
+	uint32_t timeSize; //!< [EXPORT] : [IGNORE]
+};
+
+#endif /* FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_ */

returnvalues/FwClassIds.h

@@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
+#ifndef FSFW_RETURNVALUES_FWCLASSIDS_H_
-#define FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_
+#define FSFW_RETURNVALUES_FWCLASSIDS_H_
 
 namespace CLASS_ID {
 enum {
@@ -65,9 +65,10 @@ enum {
 	POOL_VARIABLE_IF, //PVA 59
 	HOUSEKEEPING_MANAGER, //HKM 60
 	DLE_ENCODER, //DLEE 61
+	PUS_SERVICE_9, //PUS9 62
 	FW_CLASS_ID_COUNT //is actually count + 1 !
 
 };
 }
 
-#endif /* FRAMEWORK_RETURNVALUES_FWCLASSIDS_H_ */
+#endif /* FSFW_RETURNVALUES_FWCLASSIDS_H_ */

timemanager/Clock.h

@@ -9,8 +9,7 @@
 #include <sys/time.h>
 
 //! Don't use these for time points, type is not large enough for UNIX epoch.
-typedef uint32_t dur_millis_t;
+using dur_millis_t = uint32_t;
-typedef double dur_seconds_t;
 
 class Clock {
 public:

timemanager/Stopwatch.cpp

@@ -6,19 +6,22 @@ Stopwatch::Stopwatch(bool displayOnDestruction,
         StopwatchDisplayMode displayMode): displayOnDestruction(
         displayOnDestruction), displayMode(displayMode) {
     // Measures start time on initialization.
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
 void Stopwatch::start() {
-    Clock::getClock_timeval(&startTime);
+    Clock::getUptime(&startTime);
 }
 
-dur_millis_t Stopwatch::stop() {
+dur_millis_t Stopwatch::stop(bool display) {
     stopInternal();
+    if(display) {
+        this->display();
+    }
     return elapsedTime.tv_sec * 1000 + elapsedTime.tv_usec / 1000;
 }
 
-dur_seconds_t Stopwatch::stopSeconds() {
+double Stopwatch::stopSeconds() {
     stopInternal();
     return timevalOperations::toDouble(elapsedTime);
 }
@@ -52,6 +55,6 @@ StopwatchDisplayMode Stopwatch::getDisplayMode() const {
 
 void Stopwatch::stopInternal() {
 	timeval endTime;
-	Clock::getClock_timeval(&endTime);
+	Clock::getUptime(&endTime);
     elapsedTime = endTime - startTime;
 }

timemanager/Stopwatch.h

@@ -1,5 +1,6 @@
-#ifndef FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#ifndef FSFW_TIMEMANAGER_STOPWATCH_H_
-#define FRAMEWORK_TIMEMANAGER_STOPWATCH_H_
+#define FSFW_TIMEMANAGER_STOPWATCH_H_
+
 #include "Clock.h"
 
 enum class StopwatchDisplayMode {
@@ -40,12 +41,12 @@ public:
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in milliseconds (rounded)
      */
-    dur_millis_t stop();
+    dur_millis_t stop(bool display = false);
     /**
      * Calculates the elapsed time since start and returns it
      * @return elapsed time in seconds (double precision)
      */
-    dur_seconds_t stopSeconds();
+    double stopSeconds();
 
     /**
      * Displays the elapsed times on the osstream, depending on internal display
@@ -66,6 +67,4 @@ private:
 };
 
 
-
+#endif /* FSFW_TIMEMANAGER_STOPWATCH_H_ */
-
-#endif /* FRAMEWORK_TIMEMANAGER_STOPWATCH_H_ */

timemanager/TimeStamper.cpp

@@ -0,0 +1,23 @@
+#include "TimeStamper.h"
+#include "Clock.h"
+#include <cstring>
+
+TimeStamper::TimeStamper(object_id_t objectId): SystemObject(objectId) {}
+
+
+ReturnValue_t TimeStamper::addTimeStamp(uint8_t* buffer,
+		const uint8_t maxSize) {
+	if(maxSize < TimeStamperIF::MISSION_TIMESTAMP_SIZE){
+		return HasReturnvaluesIF::RETURN_FAILED;
+	}
+
+	timeval now;
+	Clock::getClock_timeval(&now);
+	CCSDSTime::CDS_short cds;
+	ReturnValue_t result = CCSDSTime::convertToCcsds(&cds,&now);
+	if(result != HasReturnvaluesIF::RETURN_OK){
+		return result;
+	}
+	std::memcpy(buffer,&cds,sizeof(cds));
+	return result;
+}

timemanager/TimeStamper.h

@@ -0,0 +1,36 @@
+#ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_
+#define FSFW_TIMEMANAGER_TIMESTAMPER_H_
+
+#include "TimeStamperIF.h"
+#include "CCSDSTime.h"
+#include "../objectmanager/SystemObject.h"
+
+/**
+ * @brief   Time stamper which can be used to add any timestamp to a
+ *          given buffer.
+ * @details
+ * This time stamper uses the CCSDS CDC short timestamp as a fault timestamp.
+ * This timestamp has a size of 8 bytes. A custom timestamp can be used by
+ * overriding the #addTimeStamp function.
+ * @ingroup utility
+ */
+class TimeStamper: public TimeStamperIF, public SystemObject {
+public:
+    /**
+     * @brief   Default constructor which also registers the time stamper as a
+     *          system object so it can be found with the #objectManager.
+     * @param objectId
+     */
+	TimeStamper(object_id_t objectId);
+
+	/**
+	 * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
+	 * This function can be overriden to use a custom timestamp.
+	 * @param buffer
+	 * @param maxSize
+	 * @return
+	 */
+	virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize);
+};
+
+#endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */

tmtcservices/CommandingServiceBase.cpp

@@ -384,7 +384,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,
 }
 
 
-void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
+void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter& iter) {
 	store_address_t address;
 	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
 		commandMap.erase(&iter);

tmtcservices/CommandingServiceBase.h

@@ -39,7 +39,11 @@ class CommandingServiceBase: public SystemObject,
 		public HasReturnvaluesIF {
 	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
+	// We could make this configurable via preprocessor and the FSFWConfig file.
+	static constexpr uint8_t COMMAND_INFO_FIFO_DEPTH = 3;
+
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
+
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
 	static const ReturnValue_t NO_STEP_MESSAGE = MAKE_RETURN_CODE(2);
 	static const ReturnValue_t OBJECT_BUSY = MAKE_RETURN_CODE(3);
@@ -223,7 +227,7 @@ protected:
 		uint32_t state;
 		Command_t command;
 		object_id_t objectId;
-		FIFO<store_address_t, 3> fifo;
+		FIFO<store_address_t, COMMAND_INFO_FIFO_DEPTH> fifo;
 
 		virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size,
 					size_t maxSize, Endianness streamEndianness) const override{
@@ -235,7 +239,7 @@ protected:
 		};
 
 		virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
-				Endianness streamEndianness) override{
+				Endianness streamEndianness) override {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		};
 	};
@@ -312,7 +316,7 @@ protected:
 	ReturnValue_t sendTmPacket(uint8_t subservice, SerializeIF* content,
 			SerializeIF* header = nullptr);
 
-	void checkAndExecuteFifo(CommandMapIter iter);
+	void checkAndExecuteFifo(CommandMapIter& iter);
 
 private:
 	/**