typo

Reviewed-on: fsfw/fsfw#736

CHANGELOG.md

@@ -12,15 +12,22 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Fixes
 
+- Bugfix in `Service11TelecommandScheduling` which allowed commands
+  time tagged in the past to be inserted.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/738
 - `CService200ModeManagement`: Various bugfixes which lead to now execution complete being generated
   on mode announcements, duplicate mode reply generated on announce commands, and the mode read
   subservice not working properly.
+- Memory leak fixes for the TCP/IP TMTC bridge.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/737
 - `Service9TimeManagement`: Fix the time dump at the `SET_TIME` subservice: Include clock timeval
   seconds instead of uptime.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/726
 - HAL MGM3100 Handler: Use axis specific gain/scaling factors. Previously,
   only the X scaling factor was used.
   PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/724
+- Bugfix for RM3100 MGM sensors. Z value was previously calculated
+  with bytes of the X value.
 - DHB `setNormalDatapoolEntriesInvalid`: The default implementation did not set the validity
   to false correctly because the `read` and `write` calls were missing.
 - PUS TMTC creator module: Sequence flags were set to continuation segment (0b00) instead
@@ -43,6 +50,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - `CServiceHealthCommanding`: Add announce all health info implementation
   PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/122
+- Empty constructor for `CdsShortTimeStamper` which does not do an object manager registration.
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/730
 - `Service9TimeManagement`: Add `DUMP_TIME` (129) subservice.
 - `TcpTmTcServer`: Allow setting the `SO_REUSEADDR` and `SO_REUSEPORT`
   option on the TCP server. CTOR prototype has changed and expects an explicit

CMakeLists.txt

@@ -153,12 +153,12 @@ if(FSFW_BUILD_TESTS)
       "${MSG_PREFIX} Building the FSFW unittests in addition to the static library"
   )
   # Check whether the user has already installed Catch2 first
-  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION})
+  find_package(Catch2 ${FSFW_CATCH2_LIB_MAJOR_VERSION} QUIET)
   # Not installed, so use FetchContent to download and provide Catch2
   if(NOT Catch2_FOUND)
     message(
       STATUS
-        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent"
+        "${MSG_PREFIX} Catch2 installation not found. Downloading Catch2 library with FetchContent."
     )
     include(FetchContent)
 
@@ -196,13 +196,13 @@ message(
 )
 
 # Check whether the user has already installed ETL first
-find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+find_package(${FSFW_ETL_LIB_NAME} ${FSFW_ETL_LIB_MAJOR_VERSION} QUIET)
 # Not installed, so use FetchContent to download and provide etl
 if(NOT ${FSFW_ETL_LIB_NAME}_FOUND)
   message(
     STATUS
-      "${MSG_PREFIX} No ETL installation was found with find_package. Installing and providing "
-      "etl with FindPackage")
+      "${MSG_PREFIX} ETL installation not found. Downloading ETL with FetchContent."
+  )
   include(FetchContent)
 
   FetchContent_Declare(

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -58,12 +58,7 @@ void DeviceHandlerBase::setHkDestination(object_id_t hkDestination) {
   this->hkDestination = hkDestination;
 }
 
-void DeviceHandlerBase::setThermalStateRequestPoolIds(lp_id_t thermalStatePoolId,
-                                                      lp_id_t heaterRequestPoolId,
-                                                      uint32_t thermalSetId) {
-  thermalSet =
-      new DeviceHandlerThermalSet(this, thermalSetId, thermalStatePoolId, heaterRequestPoolId);
-}
+void DeviceHandlerBase::setUpThermalModule(ThermalStateCfg cfg) { this->thermalStateCfg = cfg; }
 
 DeviceHandlerBase::~DeviceHandlerBase() {
   if (comCookie != nullptr) {
@@ -1477,11 +1472,11 @@ void DeviceHandlerBase::performOperationHook() {}
 
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                          LocalDataPoolManager& poolManager) {
-  if (thermalSet != nullptr) {
-    localDataPoolMap.emplace(thermalSet->thermalStatePoolId,
-                             new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>);
-    localDataPoolMap.emplace(thermalSet->heaterRequestPoolId,
-                             new PoolEntry<DeviceHandlerIF::dh_heater_request_t>);
+  if (thermalStateCfg.has_value()) {
+    localDataPoolMap.emplace(thermalStateCfg.value().thermalStatePoolId,
+                             new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>());
+    localDataPoolMap.emplace(thermalStateCfg.value().thermalRequestPoolId,
+                             new PoolEntry<DeviceHandlerIF::dh_heater_request_t>());
   }
   return returnvalue::OK;
 }
@@ -1494,6 +1489,10 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   }
   this->poolManager.initializeAfterTaskCreation();
 
+  if (thermalStateCfg.has_value()) {
+    ThermalStateCfg& cfg = thermalStateCfg.value();
+    thermalSet = new DeviceHandlerThermalSet(this, cfg);
+  }
   if (setStartupImmediately) {
     startTransition(MODE_ON, getInitialSubmode());
   }

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -2,6 +2,7 @@
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
 
 #include <map>
+#include <optional>
 
 #include "DeviceCommunicationIF.h"
 #include "DeviceHandlerFailureIsolation.h"
@@ -166,10 +167,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param thermalStatePoolId
    * @param thermalRequestPoolId
    */
-  void setThermalStateRequestPoolIds(
-      lp_id_t thermalStatePoolId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
-      lp_id_t thermalRequestPoolId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID,
-      uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID);
+  void setUpThermalModule(ThermalStateCfg cfg);
 
   ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF &parent) override;
   ModeTreeChildIF &getModeTreeChildIF() override;
@@ -931,6 +929,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   //! Object which may be the root cause of an identified fault.
   static object_id_t defaultFdirParentId;
 
+  std::optional<ThermalStateCfg> thermalStateCfg;
+
   /**
    * @brief   Send a reply to a received device handler command.
    *

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -136,4 +136,10 @@ class DeviceHandlerIF {
   virtual MessageQueueId_t getCommandQueue() const = 0;
 };
 
+struct ThermalStateCfg {
+  lp_id_t thermalStatePoolId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID;
+  lp_id_t thermalRequestPoolId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID;
+  uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID;
+};
+
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_ */

src/fsfw/devicehandlers/DeviceHandlerThermalSet.h

@@ -7,27 +7,21 @@
 
 class DeviceHandlerThermalSet : public StaticLocalDataSet<2> {
  public:
-  DeviceHandlerThermalSet(
-      HasLocalDataPoolIF* hkOwner, uint32_t setId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
-      lp_id_t thermalStateId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
-      lp_id_t heaterRequestId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID)
-      : DeviceHandlerThermalSet(hkOwner->getObjectId(), setId, thermalStateId, heaterRequestId) {}
+  DeviceHandlerThermalSet(HasLocalDataPoolIF* hkOwner, ThermalStateCfg cfg)
+      : DeviceHandlerThermalSet(hkOwner->getObjectId(), cfg) {}
 
-  DeviceHandlerThermalSet(
-      object_id_t deviceHandler, uint32_t setId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID,
-      lp_id_t thermalStateId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID,
-      lp_id_t thermalStateRequestId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID)
-      : StaticLocalDataSet(sid_t(deviceHandler, setId)),
-        thermalStatePoolId(thermalStateId),
-        heaterRequestPoolId(thermalStateRequestId) {}
+  DeviceHandlerThermalSet(object_id_t deviceHandler, ThermalStateCfg cfg)
+      : StaticLocalDataSet(sid_t(deviceHandler, cfg.thermalSetId)),
+        thermalStatePoolId(cfg.thermalStatePoolId),
+        heaterRequestPoolId(cfg.thermalRequestPoolId) {}
 
   const lp_id_t thermalStatePoolId;
   const lp_id_t heaterRequestPoolId;
 
   lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
-      lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(thermalStatePoolId, sid.objectId, this);
+      lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(sid.objectId, thermalStatePoolId, this);
   lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
-      lp_var_t<DeviceHandlerIF::dh_heater_request_t>(heaterRequestPoolId, sid.objectId, this);
+      lp_var_t<DeviceHandlerIF::dh_heater_request_t>(sid.objectId, heaterRequestPoolId, this);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_ */

src/fsfw/pus/CService200ModeCommanding.cpp

@@ -19,7 +19,7 @@ ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
   switch (subservice) {
     case (Subservice::COMMAND_MODE_COMMAND):
     case (Subservice::COMMAND_MODE_READ):
-    case (Subservice::COMMAND_MODE_ANNCOUNCE):
+    case (Subservice::COMMAND_MODE_ANNOUNCE):
     case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
       return returnvalue::OK;
     default:
@@ -54,6 +54,7 @@ ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
 ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message, uint8_t subservice,
                                                         const uint8_t *tcData, size_t tcDataLen,
                                                         uint32_t *state, object_id_t objectId) {
+  bool recursive = false;
   switch (subservice) {
     case (Subservice::COMMAND_MODE_COMMAND): {
       ModePacket modeCommandPacket;
@@ -67,22 +68,17 @@ ReturnValue_t CService200ModeCommanding::prepareCommand(CommandMessage *message,
                                   modeCommandPacket.getMode(), modeCommandPacket.getSubmode());
       return returnvalue::OK;
     }
-    case (Subservice::COMMAND_MODE_ANNCOUNCE):
-    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY): {
-      bool recursive = true;
-      if (subservice == Subservice::COMMAND_MODE_ANNCOUNCE) {
-        recursive = false;
-      }
+    case (Subservice::COMMAND_MODE_ANNOUNCE_RECURSIVELY):
+      recursive = true;
+      [[fallthrough]];
+    case (Subservice::COMMAND_MODE_ANNOUNCE):
       ModeMessage::setModeAnnounceMessage(*message, recursive);
       return EXECUTION_COMPLETE;
-    }
-    case (Subservice::COMMAND_MODE_READ): {
+    case (Subservice::COMMAND_MODE_READ):
       ModeMessage::setModeReadMessage(*message);
       return returnvalue::OK;
-    }
-    default: {
+    default:
       return CommandingServiceBase::INVALID_SUBSERVICE;
-    }
   }
 }
 

src/fsfw/pus/CService200ModeCommanding.h

@@ -52,7 +52,7 @@ class CService200ModeCommanding : public CommandingServiceBase {
     COMMAND_MODE_READ = 3,
     //!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
     //! This command does NOT have a reply
-    COMMAND_MODE_ANNCOUNCE = 4,
+    COMMAND_MODE_ANNOUNCE = 4,
     //!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
     //! command to every child. This command does NOT have a reply.
     COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,

src/fsfw/pus/Service11TelecommandScheduling.tpp

@@ -160,7 +160,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
   // (See requirement for Time margin)
   timeval tNow = {};
   Clock::getClock_timeval(&tNow);
-  if (timestamp - tNow.tv_sec <= RELEASE_TIME_MARGIN_SECONDS) {
+  if (timestamp < tNow.tv_sec + RELEASE_TIME_MARGIN_SECONDS) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "Service11TelecommandScheduling::doInsertActivity: Release time too close to "
                     "current time"

src/fsfw/timemanager/CdsShortTimeStamper.cpp

@@ -4,6 +4,8 @@
 
 #include "fsfw/timemanager/Clock.h"
 
+CdsShortTimeStamper::CdsShortTimeStamper() : SystemObject(0, false) {}
+
 CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}
 
 ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,

src/fsfw/timemanager/CdsShortTimeStamper.h

@@ -18,6 +18,7 @@
 class CdsShortTimeStamper : public TimeWriterIF, public TimeReaderIF, public SystemObject {
  public:
   static constexpr size_t TIMESTAMP_LEN = 7;
+  CdsShortTimeStamper();
   /**
    * @brief   Default constructor which also registers the time stamper as a
    *          system object so it can be found with the #objectManager.

src/fsfw/tmtcservices/TmTcBridge.h

@@ -17,7 +17,7 @@ class TmTcBridge : public AcceptsTelemetryIF,
  public:
   static constexpr uint8_t TMTC_RECEPTION_QUEUE_DEPTH = 20;
   static constexpr uint8_t LIMIT_STORED_DATA_SENT_PER_CYCLE = 15;
-  static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 1000;
+  static constexpr unsigned int LIMIT_DOWNLINK_PACKETS_STORED = 500;
 
   static constexpr uint8_t DEFAULT_STORED_DATA_SENT_PER_CYCLE = 5;
   static constexpr uint8_t DEFAULT_DOWNLINK_PACKETS_STORED = 10;