src/fsfw/FSFW.h.in

@@ -16,9 +16,37 @@
 #cmakedefine FSFW_ADD_MONITORING
 #cmakedefine FSFW_ADD_SGP4_PROPAGATOR
 
+// FSFW core defines
+
+#ifndef FSFW_CPP_OSTREAM_ENABLED
+#define FSFW_CPP_OSTREAM_ENABLED            1
+#endif /* FSFW_CPP_OSTREAM_ENABLED */
+
+#ifndef FSFW_VERBOSE_LEVEL
+#define FSFW_VERBOSE_LEVEL                  1
+#endif /* FSFW_VERBOSE_LEVEL */
+
+#ifndef FSFW_USE_REALTIME_FOR_LINUX
+#define FSFW_USE_REALTIME_FOR_LINUX         0
+#endif /* FSFW_USE_REALTIME_FOR_LINUX */
+
+#ifndef FSFW_NO_C99_IO
+#define FSFW_NO_C99_IO                      0
+#endif /* FSFW_NO_C99_IO */
+
+#ifndef FSFW_USE_PUS_C_TELEMETRY
+#define FSFW_USE_PUS_C_TELEMETRY            1
+#endif /* FSFW_USE_PUS_C_TELEMETRY */
+
+#ifndef FSFW_USE_PUS_C_TELECOMMANDS
+#define FSFW_USE_PUS_C_TELECOMMANDS         1
+#endif
+
+// FSFW HAL defines
+
 // Can be used for low-level debugging of the SPI bus
 #ifndef FSFW_HAL_SPI_WIRETAPPING
-#define FSFW_HAL_SPI_WIRETAPPING      0
+#define FSFW_HAL_SPI_WIRETAPPING            0
 #endif
 
 #ifndef FSFW_HAL_L3GD20_GYRO_DEBUG

src/fsfw/FSFWVersion.h

@@ -3,8 +3,8 @@
 
 const char* const FSFW_VERSION_NAME = "ASTP";
 
-#define FSFW_VERSION        1
+#define FSFW_VERSION        2
-#define FSFW_SUBVERSION     2
+#define FSFW_SUBVERSION     0
 #define FSFW_REVISION       0
 
 #endif /* FSFW_VERSION_H_ */

src/fsfw/osal/linux/CMakeLists.txt

@@ -13,7 +13,6 @@ target_sources(${LIB_FSFW_NAME}
 		QueueFactory.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
-		Timer.cpp
 		tcpipHelpers.cpp
 		unixUtility.cpp
 		CommandExecutor.cpp

src/fsfw/pus/Service5EventReporting.cpp

@@ -41,8 +41,7 @@ ReturnValue_t Service5EventReporting::performService() {
 	    }
 	}
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
+	sif::warning <<  "Service5EventReporting::generateEventReport: Too many events" << std::endl;
-	        " Too many events" << std::endl;
 #endif
 	return HasReturnvaluesIF::RETURN_OK;
 }
@@ -64,8 +63,11 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::debug << "Service5EventReporting::generateEventReport:"
+		sif::warning << "Service5EventReporting::generateEventReport: "
-		        " Could not send TM packet" << std::endl;
+		        "Could not send TM packet" << std::endl;
+#else
+		sif::printWarning("Service5EventReporting::generateEventReport: "
+                "Could not send TM packet\n");
 #endif
 	}
 	return result;

src/fsfw/pus/Service8FunctionManagement.cpp

@@ -33,8 +33,8 @@ ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
 	if(tcDataLen < sizeof(object_id_t)) {
 		return CommandingServiceBase::INVALID_TC;
 	}
-	SerializeAdapter::deSerialize(objectId, &tcData,
+	// Can't fail, size was checked before
-			&tcDataLen, SerializeIF::Endianness::BIG);
+	SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen, SerializeIF::Endianness::BIG);
 
 	return checkInterfaceAndAcquireMessageQueue(id,objectId);
 }

src/fsfw/returnvalues/FwClassIds.h

@@ -77,6 +77,7 @@ enum: uint8_t {
     HAL_UART, //HURT
     HAL_I2C, //HI2C
     HAL_GPIO, //HGIO
+    FIXED_SLOT_TASK_IF, //FTIF
     MGM_LIS3MDL, //MGMLIS3
     MGM_RM3100, //MGMRM3100
     SPACE_PACKET_PARSER, //SPPA

src/fsfw/tasks/FixedSlotSequence.cpp

@@ -1,4 +1,5 @@
 #include "fsfw/tasks/FixedSlotSequence.h"
+#include "fsfw/tasks/FixedTimeslotTaskIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include <cstdlib>
 
@@ -92,10 +93,9 @@ void FixedSlotSequence::addSlot(object_id_t componentId, uint32_t slotTimeMs,
 ReturnValue_t FixedSlotSequence::checkSequence() const {
 	if(slotList.empty()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "FixedSlotSequence::checkSequence:"
+		sif::warning << "FixedSlotSequence::checkSequence: Slot list is empty!" << std::endl;
-				<< " Slot list is empty!" << std::endl;
 #endif
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return FixedTimeslotTaskIF::SLOT_LIST_EMPTY;
 	}
 
 	if(customCheckFunction != nullptr) {

src/fsfw/tasks/FixedSlotSequence.h

@@ -2,7 +2,7 @@
 #define FSFW_TASKS_FIXEDSLOTSEQUENCE_H_
 
 #include "FixedSequenceSlot.h"
-#include "../objectmanager/SystemObject.h"
+#include "fsfw/objectmanager/SystemObject.h"
 
 #include <set>
 
@@ -136,6 +136,7 @@ public:
 	 * @details
 	 * Checks if timing is ok (must be ascending) and if all handlers were found.
 	 * @return
+	 *  - SLOT_LIST_EMPTY if the slot list is empty
 	 */
 	ReturnValue_t checkSequence() const;
 
@@ -147,6 +148,7 @@ public:
 	 * The general check will be continued for now if the custom check function
 	 * fails but a diagnostic debug output will be given.
 	 * @param customCheckFunction
+	 *
 	 */
 	void addCustomCheck(ReturnValue_t (*customCheckFunction)(const SlotList &));
 

src/fsfw/tasks/FixedTimeslotTaskIF.h

@@ -2,7 +2,8 @@
 #define FRAMEWORK_TASKS_FIXEDTIMESLOTTASKIF_H_
 
 #include "PeriodicTaskIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/returnvalues/FwClassIds.h"
 
 /**
  * @brief Following the same principle as the base class IF.
@@ -12,6 +13,8 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
 public:
 	virtual ~FixedTimeslotTaskIF() {}
 
+	static constexpr ReturnValue_t SLOT_LIST_EMPTY = HasReturnvaluesIF::makeReturnCode(
+	        CLASS_ID::FIXED_SLOT_TASK_IF, 0);
 	/**
 	 * Add an object with a slot time and the execution step to the task.
 	 * The execution step will be passed to the object (e.g. as an operation

src/fsfw/timemanager/Countdown.cpp

@@ -6,16 +6,14 @@ Countdown::Countdown(uint32_t initialTimeout): timeout(initialTimeout) {
 Countdown::~Countdown() {
 }
 
-ReturnValue_t Countdown::setTimeout(uint32_t miliseconds) {
+ReturnValue_t Countdown::setTimeout(uint32_t milliseconds) {
-	ReturnValue_t return_value = Clock::getUptime( &startTime );
+	ReturnValue_t returnValue = Clock::getUptime( &startTime );
-	timeout = miliseconds;
+	timeout = milliseconds;
-	return return_value;
+	return returnValue;
 }
 
 bool Countdown::hasTimedOut() const {
-	uint32_t current_time;
+	if ( uint32_t( this->getCurrentTime() - startTime) >= timeout) {
-	Clock::getUptime( &current_time );
-	if ( uint32_t(current_time - startTime) >= timeout) {
 		return true;
 	} else {
 		return false;
@@ -31,7 +29,23 @@ ReturnValue_t Countdown::resetTimer() {
 }
 
 void Countdown::timeOut() {
-	uint32_t current_time;
+	startTime = this->getCurrentTime() - timeout;
-		Clock::getUptime( &current_time );
+}
-	startTime= current_time - timeout;
+
+uint32_t Countdown::getRemainingMillis() const {
+	// We fetch the time before the if-statement
+	// to be sure that the return is in
+	// range 0 <= number <= timeout
+	uint32_t currentTime = this->getCurrentTime();
+	if (this->hasTimedOut()){
+		return 0;
+	}else{
+		return (startTime + timeout) - currentTime;
+	}
+}
+
+uint32_t Countdown::getCurrentTime() const {
+	uint32_t currentTime;
+	Clock::getUptime( &currentTime );
+	return currentTime;
 }

src/fsfw/timemanager/Countdown.h

@@ -4,28 +4,77 @@
 #include "Clock.h"
 
 /**
- * @brief	This file defines the Countdown class.
+ *
- * @author	baetz
+ * Countdown keeps track of a timespan.
+ *
+ * Countdown::resetTimer restarts the timer.
+ * Countdown::setTimeout sets a new countdown duration and resets.
+ *
+ * Can be checked with Countdown::hasTimedOut or
+ * Countdown::isBusy.
+ *
+ * Countdown::timeOut will force the timer to time out.
+ *
  */
 class Countdown {
 public:
-	uint32_t timeout;
+	/**
+	 * Constructor which sets the countdown duration in milliseconds
+	 *
+	 * It does not start the countdown!
+	 * Call resetTimer or setTimeout before usage!
+	 * Otherwise a call to hasTimedOut might return True.
+	 *
+	 * @param initialTimeout Countdown duration in milliseconds
+	 */
 	Countdown(uint32_t initialTimeout = 0);
 	~Countdown();
-	ReturnValue_t setTimeout(uint32_t miliseconds);
+	/**
-
+	 * Call to set a new countdown duration.
+	 *
+	 * Resets the countdown!
+	 *
+	 * @param milliseconds new countdown duration in milliseconds
+	 * @return Returnvalue from Clock::getUptime
+	 */
+	ReturnValue_t setTimeout(uint32_t milliseconds);
+	/**
+	 * Returns true if the countdown duration has passed.
+	 *
+	 * @return True if the countdown has passed
+	 * 		   False if it is still running
+	 */
 	bool hasTimedOut() const;
-
+	/**
+	 * Complementary to hasTimedOut.
+	 *
+	 * @return True if the countdown is till running
+	 * 		   False if it is still running
+	 */
 	bool isBusy() const;
-
+	/**
-	//!< Use last set timeout value and restart timer.
+	 *  Uses last set timeout value and restarts timer.
+	 */
 	ReturnValue_t resetTimer();
-
+	/**
-	//!< Make hasTimedOut() return true
+	 * Returns the remaining milliseconds (0 if timeout)
+	 */
+	uint32_t getRemainingMillis() const;
+	/**
+	 * Makes hasTimedOut() return true
+	 */
 	void timeOut();
-
+	/**
+	 * Internal countdown duration in milliseconds
+	 */
+	uint32_t timeout;
 private:
+	/**
+	 * Last time the timer was started (uptime)
+	 */
 	uint32_t startTime = 0;
+
+	uint32_t getCurrentTime() const;
 };
 
 #endif /* FSFW_TIMEMANAGER_COUNTDOWN_H_ */

tests/src/fsfw_tests/unit/CMakeLists.txt

@@ -18,4 +18,5 @@ add_subdirectory(serialize)
 add_subdirectory(datapoollocal)
 add_subdirectory(storagemanager)
 add_subdirectory(globalfunctions)
+add_subdirectory(timemanager)
 add_subdirectory(tmtcpacket)

tests/src/fsfw_tests/unit/timemanager/CMakeLists.txt

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

tests/src/fsfw_tests/unit/timemanager/TestCountdown.cpp

@@ -0,0 +1,27 @@
+#include "fsfw_tests/unit/CatchDefinitions.h"
+#include <fsfw/timemanager/Countdown.h>
+#include <catch2/catch_test_macros.hpp>
+
+
+TEST_CASE( "Countdown Tests", "[TestCountdown]") {
+	INFO("Countdown Tests");
+	Countdown count(20);
+	REQUIRE(count.timeout == 20);
+	REQUIRE(count.setTimeout(100) == static_cast<uint16_t>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(count.timeout == 100);
+	REQUIRE(count.setTimeout(150) == static_cast<uint16_t>(HasReturnvaluesIF::RETURN_OK));
+	REQUIRE(count.isBusy());
+	REQUIRE(not count.hasTimedOut());
+	uint32_t number = count.getRemainingMillis();
+	REQUIRE(number > 0);
+	bool blocked = false;
+	while(not count.hasTimedOut()){
+		blocked = true;
+	};
+	REQUIRE(blocked);
+	number = count.getRemainingMillis();
+	REQUIRE(number==0);
+	count.resetTimer();
+	REQUIRE(not count.hasTimedOut());
+	REQUIRE(count.isBusy());
+}