update PUS5 TM format

Reviewed-on: #49

CHANGELOG.md

@@ -26,6 +26,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
+- FreeRTOS monotonic clock which is not subjected to time jumps of the system clock
 - add CFDP subsystem ID
   https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
 - `PusTmZcWriter` now exposes API to set message counter field.

src/fsfw/datapool/PoolVariable.h

@@ -210,6 +210,7 @@ inline ReturnValue_t PoolVariable<T>::readWithoutLock() {
   }
 
   this->value = *(poolEntry->getDataPtr());
+  this->valid = poolEntry->getValid();
   return returnvalue::OK;
 }
 
@@ -241,6 +242,7 @@ ReturnValue_t PoolVariable<T>::commitWithoutLock() {
   }
 
   *(poolEntry->getDataPtr()) = this->value;
+  poolEntry->setValid(this->valid);
   return returnvalue::OK;
 }
 

src/fsfw/events/Event.h

@@ -5,28 +5,28 @@
 
 #include "fwSubsystemIdRanges.h"
 
-using EventId_t = uint16_t;
 using EventSeverity_t = uint8_t;
-using UniqueEventId_t = uint8_t;
+using GroupId_t = uint16_t;
+using UniqueEventId_t = uint16_t;
 
 namespace severity {
-enum Severity : EventSeverity_t { INFO = 1, LOW = 2, MEDIUM = 3, HIGH = 4 };
+enum Severity : EventSeverity_t { INFO = 0, LOW = 1, MEDIUM = 2, HIGH = 3 };
 
 }  // namespace severity
 
-#define MAKE_EVENT(id, severity) (((severity) << 16) + (SUBSYSTEM_ID * 100) + (id))
+#define MAKE_EVENT(id, severity) (((severity) << 30) | (SUBSYSTEM_ID << 16) | id)
 
 typedef uint32_t Event;
 
 namespace event {
 
-constexpr EventId_t getEventId(Event event) { return (event & 0xFFFF); }
+constexpr UniqueEventId_t getEventId(Event event) { return (event & 0xFFFF); }
 
-constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 16) & 0xFF); }
+constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 30) & 0b11); }
 
-constexpr Event makeEvent(uint8_t subsystemId, UniqueEventId_t uniqueEventId,
+constexpr Event makeEvent(GroupId_t groupId, UniqueEventId_t uniqueEventId,
                           EventSeverity_t eventSeverity) {
-  return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
+  return (eventSeverity << 30) | (groupId << 16) | uniqueEventId;
 }
 
 }  // namespace event

src/fsfw/osal/freertos/Clock.cpp

@@ -5,6 +5,7 @@
 
 #include "FreeRTOS.h"
 #include "fsfw/globalfunctions/timevalOperations.h"
+#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
 #include "fsfw/osal/freertos/Timekeeper.h"
 #include "task.h"
 
@@ -47,8 +48,8 @@ ReturnValue_t Clock::getClock(timeval* time) {
 }
 
 ReturnValue_t Clock::getClockMonotonic(timeval* time) {
-  // TODO: I don't actually know if the timekeeper is monotonic..
+	*time = Timekeeper::instance()->getMonotonicClockOffset() + getUptime();
-  return getClock_timeval(time);
+  return returnvalue::OK;
 }
 
 ReturnValue_t Clock::getUptime(timeval* uptime) {
@@ -58,7 +59,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 }
 
 timeval Clock::getUptime() {
-  TickType_t ticksSinceStart = xTaskGetTickCount();
+  TickType_t ticksSinceStart = Timekeeper::instance()->getTicks();
   return Timekeeper::ticksToTimeval(ticksSinceStart);
 }
 

src/fsfw/osal/freertos/Timekeeper.cpp

@@ -17,7 +17,13 @@ Timekeeper* Timekeeper::instance() {
   return myinstance;
 }
 
-void Timekeeper::setOffset(const timeval& offset) { this->offset = offset; }
+void Timekeeper::setOffset(const timeval& offset) {
+	if (not monotonicClockInitialized) {
+		this->monotonicClockOffset = offset;
+		monotonicClockInitialized = true;
+	}
+	this->offset = offset;
+}
 
 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
   timeval uptime;
@@ -33,3 +39,7 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 }
 
 TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); }
+
+const timeval Timekeeper::getMonotonicClockOffset() const {
+	return monotonicClockOffset;
+}

src/fsfw/osal/freertos/Timekeeper.h

@@ -18,9 +18,14 @@ class Timekeeper {
   Timekeeper();
 
   timeval offset;
+  // Set when offset is initialized the first time
+  timeval monotonicClockOffset;
+  bool monotonicClockInitialized = false;
 
   static Timekeeper* myinstance;
 
+  void setMonotonicClockOffset(const timeval& monotonicClockOffset);
+
  public:
   static Timekeeper* instance();
   virtual ~Timekeeper();
@@ -34,6 +39,7 @@ class Timekeeper {
 
   const timeval& getOffset() const;
   void setOffset(const timeval& offset);
+  const timeval getMonotonicClockOffset() const;
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */

src/fsfw/pus/Service5EventReporting.cpp

@@ -44,7 +44,7 @@ ReturnValue_t Service5EventReporting::performService() {
 }
 
 ReturnValue_t Service5EventReporting::generateEventReport(EventMessage message) {
-  EventReport report(message.getEventId(), message.getReporter(), message.getParameter1(),
+  EventReport report(message.getEvent(), message.getReporter(), message.getParameter1(),
                      message.getParameter2());
   storeHelper.preparePacket(psbParams.serviceId, message.getSeverity(), tmHelper.sendCounter);
   storeHelper.setSourceDataSerializable(report);

src/fsfw/pus/servicepackets/Service5Packets.h

@@ -17,17 +17,13 @@
  */
 class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
  public:
-  EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
+  EventReport(Event event_, object_id_t objectId_, uint32_t parameter1_, uint32_t parameter2_)
-              uint32_t parameter2_)
+      : event(event_), objectId(objectId_), parameter1(parameter1_), parameter2(parameter2_) {}
-      : reportId(reportId_),
-        objectId(objectId_),
-        parameter1(parameter1_),
-        parameter2(parameter2_) {}
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                           SerializeIF::Endianness streamEndianness) const override {
     ReturnValue_t result =
-        SerializeAdapter::serialize(&reportId, buffer, size, maxSize, streamEndianness);
+        SerializeAdapter::serialize(&event, buffer, size, maxSize, streamEndianness);
     if (result != returnvalue::OK) {
       return result;
     }
@@ -48,7 +44,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
 
   size_t getSerializedSize() const override {
     uint32_t size = 0;
-    size += SerializeAdapter::getSerializedSize(&reportId);
+    size += SerializeAdapter::getSerializedSize(&event);
     size += SerializeAdapter::getSerializedSize(&objectId);
     size += SerializeAdapter::getSerializedSize(&parameter1);
     size += SerializeAdapter::getSerializedSize(&parameter2);
@@ -61,7 +57,7 @@ class EventReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 2, 3,
   }
 
  private:
-  EventId_t reportId;
+  Event event;
   object_id_t objectId;
   uint32_t parameter1;
   uint32_t parameter2;

src/fsfw/serviceinterface/ServiceInterfacePrinter.cpp

@@ -75,7 +75,7 @@ void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
   /*
    * Log current time to terminal if desired.
    */
-  len += sprintf(bufferPosition + len, " | %lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
+  len += sprintf(bufferPosition + len, " | %02lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
                  (unsigned long)now.minute, (unsigned long)now.second,
                  (unsigned long)now.usecond / 1000);
 

src/fsfw/subsystem/SubsystemBase.cpp

@@ -79,22 +79,36 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
     }
 
     if (healthHelper.healthTable->hasHealth(object)) {
-      if (healthHelper.healthTable->isFaulty(object)) {
+
+      switch (healthHelper.healthTable->getHealth(object)) {
+        case NEEDS_RECOVERY:
+        case FAULTY:
+        case PERMANENT_FAULTY:
           ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
                                       SUBMODE_NONE);
-      } else {
+          break;
+        case HEALTHY:
           if (modeHelper.isForced()) {
             ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
                                         tableIter.value->getMode(), submodeToCommand);
           } else {
-          if (healthHelper.healthTable->isCommandable(object)) {
             ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
                                         tableIter.value->getMode(), submodeToCommand);
+          }
+          break;
+        case EXTERNAL_CONTROL:
+          if (modeHelper.isForced()) {
+            ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
+                                        tableIter.value->getMode(), submodeToCommand);
           } else {
             continue;
           }
+          break;
+        default:
+          // This never happens
+          break;
       }
-      }
+
     } else {
       ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
                                   tableIter.value->getMode(), submodeToCommand);

src/fsfw/thermal/TemperatureSensor.h

@@ -142,7 +142,7 @@ class TemperatureSensor : public AbstractTemperatureSensor {
 
       deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.) -
                   (uptimeOfOldTemperature.tv_sec + uptimeOfOldTemperature.tv_usec / 1000000.);
-      deltaTemp = oldTemperature - outputTemperature;
+      deltaTemp = oldTemperature - outputTemperature.value;
       if (deltaTemp < 0) {
         deltaTemp = -deltaTemp;
       }
@@ -160,13 +160,13 @@ class TemperatureSensor : public AbstractTemperatureSensor {
       outputTemperature.setValid(PoolVariableIF::INVALID);
       outputTemperature = thermal::INVALID_TEMPERATURE;
     } else {
-      oldTemperature = outputTemperature;
+      oldTemperature = outputTemperature.value;
       uptimeOfOldTemperature = uptime;
     }
   }
 
  public:
-  float getTemperature() { return outputTemperature; }
+  float getTemperature() { return outputTemperature.value; }
 
   bool isValid() { return outputTemperature.isValid(); }
 

src/fsfw/timemanager/Clock.h

@@ -192,6 +192,8 @@ class Clock {
   static MutexIF *timeMutex;
   static uint16_t leapSeconds;
   static bool leapSecondsSet;
+  static bool monotonicClockInitialized;
+  static timeval monotonicClockOffset;
 };
 
 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */