Merge branch 'development' into mueller/possible-ring-buffer-fix

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -787,9 +787,9 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   // Serialize set packet into store.
   size_t size = 0;
   result = setPacket.serialize(&storePtr, &size, expectedSize, SerializeIF::Endianness::BIG);
-  if(result != HasReturnvaluesIF::RETURN_OK) {
-      ipcStore->deleteData(storeId);
-      return result;
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    ipcStore->deleteData(storeId);
+    return result;
   }
   if (expectedSize != size) {
     printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
@@ -806,8 +806,8 @@ ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, bool i
   }
 
   result = hkQueue->reply(&reply);
-  if(result != HasReturnvaluesIF::RETURN_OK) {
-      ipcStore->deleteData(storeId);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    ipcStore->deleteData(storeId);
   }
   return result;
 }

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -458,16 +458,15 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
   DeviceCommandId_t replyId = NO_COMMAND_ID;
   DeviceCommandMap::iterator command = cookieInfo.pendingCommand;
   if (command->second.useAlternativeReplyId) {
-	replyId = command->second.alternativeReplyId;
-  }
-  else {
-	replyId = commandId;
+    replyId = command->second.alternativeReplyId;
+  } else {
+    replyId = commandId;
   }
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
   if (iter != deviceReplyMap.end()) {
-	if (iter->second.delayCycles != 0) {
-		return iter->second.replyLen;
-	}
+    if (iter->second.delayCycles != 0) {
+      return iter->second.replyLen;
+    }
   }
   return 0;
 }

src/fsfw/ipc/MessageQueueBase.cpp

@@ -1,9 +1,9 @@
 #include "MessageQueueBase.h"
 
-MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest,
-    MqArgs* args): id(id) {
+MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* args)
+    : id(id) {
   this->defaultDest = defaultDest;
-  if(args != nullptr) {
+  if (args != nullptr) {
     this->args = *args;
   }
 }
@@ -23,35 +23,25 @@ ReturnValue_t MessageQueueBase::reply(MessageQueueMessageIF* message) {
 }
 
 ReturnValue_t MessageQueueBase::receiveMessage(MessageQueueMessageIF* message,
-                                           MessageQueueId_t* receivedFrom) {
+                                               MessageQueueId_t* receivedFrom) {
   ReturnValue_t status = this->receiveMessage(message);
   *receivedFrom = this->last;
   return status;
 }
 
-MessageQueueId_t MessageQueueBase::getLastPartner() const {
-  return last;
-}
+MessageQueueId_t MessageQueueBase::getLastPartner() const { return last; }
 
-MessageQueueId_t MessageQueueBase::getId() const {
-  return id;
-}
+MessageQueueId_t MessageQueueBase::getId() const { return id; }
 
-MqArgs& MessageQueueBase::getMqArgs() {
-  return args;
-}
+MqArgs& MessageQueueBase::getMqArgs() { return args; }
 
 void MessageQueueBase::setDefaultDestination(MessageQueueId_t defaultDestination) {
   this->defaultDest = defaultDestination;
 }
 
-MessageQueueId_t MessageQueueBase::getDefaultDestination() const {
-  return defaultDest;
-}
+MessageQueueId_t MessageQueueBase::getDefaultDestination() const { return defaultDest; }
 
-bool MessageQueueBase::isDefaultDestinationSet() const {
-  return (defaultDest != NO_QUEUE);
-}
+bool MessageQueueBase::isDefaultDestinationSet() const { return (defaultDest != NO_QUEUE); }
 
 ReturnValue_t MessageQueueBase::sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                             bool ignoreFault) {

src/fsfw/ipc/MessageQueueBase.h

@@ -1,11 +1,11 @@
 #ifndef FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
 #define FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_
 
-#include <fsfw/ipc/definitions.h>
 #include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/definitions.h>
 
-class MessageQueueBase: public MessageQueueIF {
-public:
+class MessageQueueBase : public MessageQueueIF {
+ public:
   MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
   virtual ~MessageQueueBase();
 
@@ -17,25 +17,24 @@ public:
   virtual MessageQueueId_t getDefaultDestination() const override;
   virtual bool isDefaultDestinationSet() const override;
   virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-      bool ignoreFault) override;
+                                    bool ignoreFault) override;
   virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
   virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
   virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-      MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message,
-      MessageQueueId_t sentFrom, bool ignoreFault = false) override;
+                                       MessageQueueId_t* receivedFrom) override;
+  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+                                          bool ignoreFault = false) override;
 
   // OSAL specific, forward the abstract function
   virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
   virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                         MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
-protected:
+
+ protected:
   MessageQueueId_t id = MessageQueueIF::NO_QUEUE;
   MessageQueueId_t last = MessageQueueIF::NO_QUEUE;
   MessageQueueId_t defaultDest = MessageQueueIF::NO_QUEUE;
   MqArgs args = {};
 };
 
-
-
 #endif /* FSFW_SRC_FSFW_IPC_MESSAGEQUEUEBASE_H_ */

src/fsfw/ipc/MessageQueueIF.h

@@ -2,6 +2,7 @@
 #define FSFW_IPC_MESSAGEQUEUEIF_H_
 
 #include <fsfw/ipc/definitions.h>
+
 #include <cstdint>
 
 #include "../returnvalues/HasReturnvaluesIF.h"
@@ -45,7 +46,8 @@ class MessageQueueIF {
   virtual ReturnValue_t reply(MessageQueueMessageIF* message) = 0;
 
   /**
-   * @brief	This function reads available messages from the message queue and returns the sender.
+   * @brief	This function reads available messages from the message queue and returns the
+   * sender.
    * @details
    * It works identically to the other receiveMessage call, but in addition
    * returns the sender's queue id.

src/fsfw/osal/freertos/Clock.cpp

@@ -11,9 +11,6 @@
 // TODO sanitize input?
 // TODO much of this code can be reused for tick-only systems
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
 uint32_t Clock::getTicksPerSecond(void) { return 1000; }
 
 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {

src/fsfw/osal/freertos/MessageQueue.h

@@ -2,6 +2,7 @@
 #define FSFW_OSAL_FREERTOS_MESSAGEQUEUE_H_
 
 #include <fsfw/ipc/MessageQueueBase.h>
+
 #include "FreeRTOS.h"
 #include "TaskManagement.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"

src/fsfw/osal/host/Clock.cpp

@@ -2,6 +2,7 @@
 
 #include <chrono>
 
+#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/platform.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
@@ -11,9 +12,6 @@
 #include <fstream>
 #endif
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
 using SystemClock = std::chrono::system_clock;
 
 uint32_t Clock::getTicksPerSecond(void) {
@@ -127,6 +125,13 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
   auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(now);
   auto fraction = now - seconds;
   time_t tt = SystemClock::to_time_t(now);
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  MutexGuard helper(timeMutex);
+  // gmtime writes its output in a global buffer which is not Thread Safe
+  // Therefore we have to use a Mutex here
   struct tm* timeInfo;
   timeInfo = gmtime(&tt);
   time->year = timeInfo->tm_year + 1900;

src/fsfw/osal/host/MessageQueue.h

@@ -1,17 +1,17 @@
 #ifndef FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
 #define FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_
 
-#include "fsfw/ipc/MessageQueueBase.h"
+#include <memory>
+#include <queue>
+
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
+#include "fsfw/ipc/MessageQueueBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/ipc/definitions.h"
 #include "fsfw/timemanager/Clock.h"
 
-#include <memory>
-#include <queue>
-
 /**
  * @brief		This class manages sending and receiving of
  * 				message queue messages.

src/fsfw/osal/linux/Clock.cpp

@@ -8,11 +8,9 @@
 
 #include <fstream>
 
+#include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = NULL;
-
 uint32_t Clock::getTicksPerSecond(void) {
   uint32_t ticks = sysconf(_SC_CLK_TCK);
   return ticks;
@@ -117,7 +115,13 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
     // TODO errno
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  MutexGuard helper(timeMutex);
+  // gmtime writes its output in a global buffer which is not Thread Safe
+  // Therefore we have to use a Mutex here
   struct tm* timeInfo;
   timeInfo = gmtime(&timeUnix.tv_sec);
   time->year = timeInfo->tm_year + 1900;

src/fsfw/osal/linux/MessageQueue.h

@@ -61,8 +61,7 @@ class MessageQueue : public MessageQueueBase {
   ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
   ReturnValue_t flush(uint32_t* count) override;
   ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom,
-                                        bool ignoreFault = false) override;
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;
 
  protected:
   /**

src/fsfw/osal/rtems/Clock.cpp

@@ -6,9 +6,6 @@
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/osal/rtems/RtemsBasic.h"
 
-uint16_t Clock::leapSeconds = 0;
-MutexIF* Clock::timeMutex = nullptr;
-
 uint32_t Clock::getTicksPerSecond(void) {
   rtems_interval ticks_per_second = rtems_clock_get_ticks_per_second();
   return static_cast<uint32_t>(ticks_per_second);

src/fsfw/osal/rtems/MessageQueue.h

@@ -2,6 +2,7 @@
 #define FSFW_OSAL_RTEMS_MESSAGEQUEUE_H_
 
 #include <fsfw/ipc/MessageQueueBase.h>
+
 #include "RtemsBasic.h"
 #include "fsfw/internalerror/InternalErrorReporterIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
@@ -52,8 +53,8 @@ class MessageQueue : public MessageQueueBase {
   // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
   ReturnValue_t flush(uint32_t* count) override;
   ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom = NO_QUEUE,
-                                        bool ignoreFault = false) override;
+                                MessageQueueId_t sentFrom = NO_QUEUE,
+                                bool ignoreFault = false) override;
 
  private:
   /**

src/fsfw/osal/rtems/PeriodicTask.h

@@ -59,14 +59,13 @@ class PeriodicTask : public RTEMSTaskBase, public PeriodicTaskIF {
    */
   ReturnValue_t addComponent(object_id_t object) override;
 
-/**
+  /**
    * Adds an object to the list of objects to be executed.
    * The objects are executed in the order added.
    * @param object pointer to the object to add.
    * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
    */
-  ReturnValue_t addComponent(ExecutableObjectIF* object) override;
-
+  ReturnValue_t addComponent(ExecutableObjectIF *object) override;
 
   uint32_t getPeriodMs() const override;
 

src/fsfw/timemanager/CCSDSTime.cpp

@@ -91,7 +91,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const uint8_t* f
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return convertTimevalToTimeOfDay(to, &time);
+  return Clock::convertTimevalToTimeOfDay(&time, to);
 }
 
 ReturnValue_t CCSDSTime::convertFromCCS(Clock::TimeOfDay_t* to, const uint8_t* from,
@@ -489,11 +489,6 @@ ReturnValue_t CCSDSTime::checkTimeOfDay(const Clock::TimeOfDay_t* time) {
   return RETURN_OK;
 }
 
-ReturnValue_t CCSDSTime::convertTimevalToTimeOfDay(Clock::TimeOfDay_t* to, timeval* from) {
-  // This is rather tricky. Implement only if needed. Also, if so, move to OSAL.
-  return UNSUPPORTED_TIME_FORMAT;
-}
-
 ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from, size_t* foundLength,
                                         size_t maxLength) {
   uint8_t pField = *from;
@@ -583,7 +578,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(Clock::TimeOfDay_t* to, const CCSDSTime:
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return CCSDSTime::convertTimevalToTimeOfDay(to, &tempTimeval);
+  return Clock::convertTimevalToTimeOfDay(&tempTimeval, to);
 }
 
 ReturnValue_t CCSDSTime::convertFromCUC(timeval* to, uint8_t pField, const uint8_t* from,

src/fsfw/timemanager/CCSDSTime.h

@@ -223,7 +223,6 @@ class CCSDSTime : public HasReturnvaluesIF {
                                          uint8_t *day);
 
   static bool isLeapYear(uint32_t year);
-  static ReturnValue_t convertTimevalToTimeOfDay(Clock::TimeOfDay_t *to, timeval *from);
 };
 
 #endif /* FSFW_TIMEMANAGER_CCSDSTIME_H_ */

src/fsfw/timemanager/Clock.h

@@ -99,6 +99,13 @@ class Clock {
    */
   static ReturnValue_t getDateAndTime(TimeOfDay_t *time);
 
+  /**
+   * Convert to time of day struct given the POSIX timeval struct
+   * @param from
+   * @param to
+   * @return
+   */
+  static ReturnValue_t convertTimevalToTimeOfDay(const timeval *from, TimeOfDay_t *to);
   /**
    * Converts a time of day struct to POSIX seconds.
    * @param time The time of day as input
@@ -166,6 +173,7 @@ class Clock {
 
   static MutexIF *timeMutex;
   static uint16_t leapSeconds;
+  static bool leapSecondsSet;
 };
 
 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */

src/fsfw/timemanager/ClockCommon.cpp

@@ -1,7 +1,13 @@
+#include <ctime>
+
 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/timemanager/Clock.h"
 
-ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval *tt) {
+uint16_t Clock::leapSeconds = 0;
+MutexIF* Clock::timeMutex = nullptr;
+bool Clock::leapSecondsSet = false;
+
+ReturnValue_t Clock::convertUTCToTT(timeval utc, timeval* tt) {
   uint16_t leapSeconds;
   ReturnValue_t result = getLeapSeconds(&leapSeconds);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -27,12 +33,16 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
   MutexGuard helper(timeMutex);
 
   leapSeconds = leapSeconds_;
+  leapSecondsSet = true;
 
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
-  if (timeMutex == nullptr) {
+ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
+  if (not leapSecondsSet) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
   MutexGuard helper(timeMutex);
@@ -42,9 +52,32 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t *leapSeconds_) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
+ReturnValue_t Clock::convertTimevalToTimeOfDay(const timeval* from, TimeOfDay_t* to) {
+  struct tm* timeInfo;
+  // According to https://en.cppreference.com/w/c/chrono/gmtime, the implementation of gmtime_s
+  // in the Windows CRT is incompatible with the C standard but this should not be an issue for
+  // this implementation
+  ReturnValue_t result = checkOrCreateClockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  MutexGuard helper(timeMutex);
+  // gmtime writes its output in a global buffer which is not Thread Safe
+  // Therefore we have to use a Mutex here
+  timeInfo = gmtime(&from->tv_sec);
+  to->year = timeInfo->tm_year + 1900;
+  to->month = timeInfo->tm_mon + 1;
+  to->day = timeInfo->tm_mday;
+  to->hour = timeInfo->tm_hour;
+  to->minute = timeInfo->tm_min;
+  to->second = timeInfo->tm_sec;
+  to->usecond = from->tv_usec;
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
 ReturnValue_t Clock::checkOrCreateClockMutex() {
   if (timeMutex == nullptr) {
-    MutexFactory *mutexFactory = MutexFactory::instance();
+    MutexFactory* mutexFactory = MutexFactory::instance();
     if (mutexFactory == nullptr) {
       return HasReturnvaluesIF::RETURN_FAILED;
     }

src/fsfw/version.cpp

@@ -1,8 +1,9 @@
 #include "version.h"
-#include "fsfw/FSFWVersion.h"
 
 #include <cstdio>
 
+#include "fsfw/FSFWVersion.h"
+
 #ifdef major
 #undef major
 #endif

src/fsfw/version.h

@@ -29,7 +29,7 @@ class Version {
   }
 
   friend bool operator>(const Version& v1, const Version& v2) {
-    return not (v1 < v2) and not (v1 == v2);
+    return not(v1 < v2) and not(v1 == v2);
   }
 
   friend bool operator<=(const Version& v1, const Version& v2) { return ((v1 == v2) or (v1 < v2)); }