Merge pull request 'Periodic HK helper simplification' (#136) from periodic_hk_helper_simplification into develop

Reviewed-on: eive/fsfw#136

CHANGELOG.md

@@ -16,6 +16,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - Rename FW subsystem ID from `PCDU_2` to `POWER_SYSTEM_IF`.
 - Add new `SWITCH_UNKNOWN` returnvalue in `PowerSwitchIF`.
+- Simplify `PeriodicHousekeepingHelper`: No non-diagnostic handling.
+  Start removing the distinction between diagnostics and regular
+  HK packets.
 - Pool Manager now allows enabling the `spillToHigherPools` option.
 
 # [v6.0.0]

src/fsfw/datapoollocal/LocalDataPoolManager.cpp

@@ -70,8 +70,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
   return returnvalue::OK;
 }
 
-ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation(uint8_t nonDiagInvlFactor) {
+ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation() {
-  setNonDiagnosticIntervalFactor(nonDiagInvlFactor);
   return initializeHousekeepingPoolEntriesOnce();
 }
 
@@ -661,10 +660,6 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(HousekeepingPacke
   return hkPacket.serialize(&dataPtr, serializedSize, maxSize, SerializeIF::Endianness::MACHINE);
 }
 
-void LocalDataPoolManager::setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor) {
-  this->nonDiagnosticIntervalFactor = nonDiagInvlFactor;
-}
-
 void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
   sid_t sid = receiver.dataId.sid;
   LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);

src/fsfw/datapoollocal/LocalDataPoolManager.h

@@ -102,7 +102,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
    * @param nonDiagInvlFactor
    * @return
    */
-  ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
+  ReturnValue_t initializeAfterTaskCreation();
 
   /**
    * @brief   This should be called in the periodic handler of the owner.
@@ -152,17 +152,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
                                                   MessageQueueId_t targetQueueId,
                                                   bool generateSnapshot) override;
 
-  /**
-   * Non-Diagnostics packets usually have a lower minimum sampling frequency
-   * than diagnostic packets.
-   * A factor can be specified to determine the minimum sampling frequency
-   * for non-diagnostic packets. The minimum sampling frequency of the
-   * diagnostics packets,which is usually jusst the period of the
-   * performOperation calls, is multiplied with that factor.
-   * @param factor
-   */
-  void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
-
   /**
    * @brief   The manager is also able to handle housekeeping messages.
    * @details

src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp

@@ -250,9 +250,8 @@ void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
 bool LocalPoolDataSetBase::getReportingEnabled() const { return reportingEnabled; }
 
 void LocalPoolDataSetBase::initializePeriodicHelper(float collectionInterval,
-                                                    dur_millis_t minimumPeriodicInterval,
+                                                    dur_millis_t minimumPeriodicInterval) {
-                                                    uint8_t nonDiagIntervalFactor) {
+  periodicHelper->initialize(collectionInterval, minimumPeriodicInterval);
-  periodicHelper->initialize(collectionInterval, minimumPeriodicInterval, nonDiagIntervalFactor);
 }
 
 void LocalPoolDataSetBase::setChanged(bool changed) { this->changed = changed; }

src/fsfw/datapoollocal/LocalPoolDataSetBase.h

@@ -191,8 +191,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   bool reportingEnabled = false;
 
-  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+  void initializePeriodicHelper(float collectionInterval, dur_millis_t minimumPeriodicInterval);
-                                uint8_t nonDiagIntervalFactor = 5);
 
   /**
    * If the valid state of a dataset is always relevant to the whole

src/fsfw/datapoollocal/internal/LocalPoolDataSetAttorney.h

@@ -12,10 +12,8 @@ class LocalPoolDataSetAttorney {
   static bool isDiagnostics(LocalPoolDataSetBase& set) { return set.isDiagnostics(); }
 
   static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-                                       uint32_t minimumPeriodicIntervalMs,
+                                       uint32_t minimumPeriodicIntervalMs) {
-                                       uint8_t nonDiagIntervalFactor = 5) {
+    set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs);
-    set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs,
-                                 nonDiagIntervalFactor);
   }
 
   static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {

src/fsfw/housekeeping/PeriodicHousekeepingHelper.cpp

@@ -8,10 +8,8 @@ PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(LocalPoolDataSetBase* own
     : owner(owner) {}
 
 void PeriodicHousekeepingHelper::initialize(float collectionInterval,
-                                            dur_millis_t minimumPeriodicInterval,
+                                            dur_millis_t minimumPeriodicInterval) {
-                                            uint8_t nonDiagIntervalFactor) {
   this->minimumPeriodicInterval = minimumPeriodicInterval;
-  this->nonDiagIntervalFactor = nonDiagIntervalFactor;
   collectionIntervalTicks = intervalSecondsToIntervalTicks(collectionInterval);
   /* This will cause a checkOpNecessary call to be true immediately. I think it's okay
       if a HK packet is generated immediately instead of waiting one generation cycle. */
@@ -36,42 +34,17 @@ uint32_t PeriodicHousekeepingHelper::intervalSecondsToIntervalTicks(
   if (owner == nullptr) {
     return 0;
   }
-  bool isDiagnostics = owner->isDiagnostics();
 
   /* Avoid division by zero */
   if (minimumPeriodicInterval == 0) {
-    if (isDiagnostics) {
+    /* Perform operation each cycle */
-      /* Perform operation each cycle */
+    return 1;
-      return 1;
+
-    } else {
-      return nonDiagIntervalFactor;
-    }
   } else {
     dur_millis_t intervalInMs = collectionIntervalSeconds * 1000;
     uint32_t divisor = minimumPeriodicInterval;
-    if (not isDiagnostics) {
-      /* We need to multiply the divisor because non-diagnostics only
-      allow a multiple of the minimum periodic interval */
-      divisor *= nonDiagIntervalFactor;
-    }
     uint32_t ticks = std::ceil(static_cast<float>(intervalInMs) / divisor);
-    if (not isDiagnostics) {
-      /* Now we need to multiply the calculated ticks with the factor as as well
-      because the minimum tick count to generate a non-diagnostic is the factor itself.
 
-      Example calculation for non-diagnostic with
-      0.4 second interval and 0.2 second task interval.
-      Resultant tick count of 5 is equal to operation each second.
-
-      Examle calculation for non-diagnostic with  2.0 second interval and 0.2 second
-      task interval.
-      Resultant tick count of 10 is equal to operatin every 2 seconds.
-
-      Example calculation for diagnostic with 0.4 second interval and 0.3
-      second task interval. Resulting tick count of 2 is equal to operation
-      every 0.6 seconds. */
-      ticks *= nonDiagIntervalFactor;
-    }
     return ticks;
   }
 }

src/fsfw/housekeeping/PeriodicHousekeepingHelper.h

@@ -11,8 +11,7 @@ class PeriodicHousekeepingHelper {
  public:
   PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
 
-  void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval,
+  void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval);
-                  uint8_t nonDiagIntervalFactor);
 
   void changeCollectionInterval(float newInterval);
   float getCollectionIntervalInSeconds() const;
@@ -20,7 +19,6 @@ class PeriodicHousekeepingHelper {
 
  private:
   LocalPoolDataSetBase* owner = nullptr;
-  uint8_t nonDiagIntervalFactor = 0;
 
   uint32_t intervalSecondsToIntervalTicks(float collectionIntervalSeconds);
   float intervalTicksToSeconds(uint32_t collectionInterval) const;