From 9ecbc8199e458e6c56a91c4de91b6217d30d9ea3 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" Date: Sat, 19 Sep 2020 02:46:29 +0200 Subject: [PATCH] added periodic helper --- datapoollocal/LocalDataPoolManager.cpp | 92 ++++++++++++--------- datapoollocal/LocalDataPoolManager.h | 3 +- datapoollocal/LocalPoolDataSetBase.cpp | 3 + datapoollocal/LocalPoolDataSetBase.h | 15 ++-- housekeeping/HousekeepingSetPacket.h | 49 ++++++++++- housekeeping/PeriodicHousekeepingHelper.cpp | 47 +++++++++++ housekeeping/PeriodicHousekeepingHelper.h | 35 ++++++++ 7 files changed, 195 insertions(+), 49 deletions(-) create mode 100644 housekeeping/PeriodicHousekeepingHelper.cpp create mode 100644 housekeeping/PeriodicHousekeepingHelper.h diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index 17c7ad1d..48d57a91 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -1,3 +1,4 @@ +#include #include "LocalDataPoolManager.h" #include "LocalPoolDataSetBase.h" #include "../housekeeping/AcceptsHkPacketsIF.h" @@ -155,8 +156,8 @@ ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage( case(HousekeepingMessage::REPORT_DIAGNOSTICS_REPORT_STRUCTURES): case(HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): - return generateSetStructurePacket(sid); - + //return generateSetStructurePacket(sid, ); + return HasReturnvaluesIF::RETURN_OK; case(HousekeepingMessage::MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL): case(HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): { float newCollIntvl = 0; @@ -274,40 +275,11 @@ ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore( SerializeIF::Endianness::MACHINE); } -ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) { - LocalPoolDataSetBase* dataSet = dynamic_cast( - owner->getDataSetHandle(sid)); - if(dataSet == nullptr) { - sif::warning << "HousekeepingManager::generateHousekeepingPacket:" - " Set ID not found" << std::endl; - return HasReturnvaluesIF::RETURN_FAILED; - } - size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t); - uint8_t* storePtr = nullptr; - store_address_t storeId; - ReturnValue_t result = ipcStore->getFreeElement(&storeId, - expectedSize,&storePtr); - if(result != HasReturnvaluesIF::RETURN_OK) { - sif::error << "HousekeepingManager::generateHousekeepingPacket: " - "Could not get free element from IPC store." << std::endl; - return result; - } - size_t size = 0; - result = dataSet->serializeLocalPoolIds(&storePtr, &size, - expectedSize, SerializeIF::Endianness::BIG); - if(expectedSize != size) { - sif::error << "HousekeepingManager::generateSetStructurePacket: " - "Expected size is not equal to serialized size" << std::endl; - } - return result; -} - void LocalDataPoolManager::setNonDiagnosticIntervalFactor( uint8_t nonDiagInvlFactor) { this->nonDiagnosticIntervalFactor = nonDiagInvlFactor; } - void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) { if(receiver->intervalCounter >= receiver->hkParameter.collectionIntervalTicks) { @@ -386,14 +358,56 @@ ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid, return WRONG_HK_PACKET_TYPE; } - for(auto& receiver: hkReceiversMap) { - if(receiver.second.reportingType != ReportingType::PERIODIC) { - continue; - } - - uint32_t newInterval = intervalSecondsToInterval(isDiagnostics, - newCollectionInterval); - receiver.second.hkParameter.collectionIntervalTicks = newInterval; + if(dataSet->periodicHelper == nullptr) { + // config error + return HasReturnvaluesIF::RETURN_FAILED; } + + dataSet->periodicHelper->changeCollectionInterval(newCollectionInterval); +// for(auto& receiver: hkReceiversMap) { +// if(receiver.second.reportingType != ReportingType::PERIODIC) { +// continue; +// } +// +// uint32_t newInterval = intervalSecondsToInterval(isDiagnostics, +// newCollectionInterval); +// receiver.second.hkParameter.collectionIntervalTicks = newInterval; +// } return HasReturnvaluesIF::RETURN_OK; } + +ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid, + float collectionInterval, bool isDiagnostics) { + LocalPoolDataSetBase* dataSet = dynamic_cast( + owner->getDataSetHandle(sid)); + if(dataSet == nullptr) { + sif::warning << "HousekeepingManager::generateHousekeepingPacket:" + " Set ID not found" << std::endl; + return HasReturnvaluesIF::RETURN_FAILED; + } + + bool valid = dataSet->isValid(); + bool targetIsDiagnostics = dataSet->getIsDiagnostics(); + bool reportingEnabled = dataSet->getReportingEnabled(); + + size_t expectedSize = dataSet->getFillCount() * sizeof(lp_id_t); + uint8_t* storePtr = nullptr; + store_address_t storeId; + HousekeepingSetPacket setPacket = HousekeepingSetPacket(sid, reportingEnabled, + valid, collectionInterval, dataSet); + ReturnValue_t result = ipcStore->getFreeElement(&storeId, + expectedSize,&storePtr); + if(result != HasReturnvaluesIF::RETURN_OK) { + sif::error << "HousekeepingManager::generateHousekeepingPacket: " + "Could not get free element from IPC store." << std::endl; + return result; + } + size_t size = 0; + result = dataSet->serializeLocalPoolIds(&storePtr, &size, + expectedSize, SerializeIF::Endianness::BIG); + if(expectedSize != size) { + sif::error << "HousekeepingManager::generateSetStructurePacket: " + "Expected size is not equal to serialized size" << std::endl; + } + return result; +} diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h index 559b8cc2..2a5c68b5 100644 --- a/datapoollocal/LocalDataPoolManager.h +++ b/datapoollocal/LocalDataPoolManager.h @@ -114,7 +114,6 @@ public: ReturnValue_t generateHousekeepingPacket(sid_t sid, LocalPoolDataSetBase* dataSet, bool forDownlink, MessageQueueId_t destination = MessageQueueIF::NO_QUEUE); - ReturnValue_t generateSetStructurePacket(sid_t sid); ReturnValue_t handleHousekeepingMessage(CommandMessage* message); @@ -263,6 +262,8 @@ private: bool isDiagnostics); ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval, bool isDiagnostics); + ReturnValue_t generateSetStructurePacket(sid_t sid, + float collectionInterval, bool isDiagnostics); }; diff --git a/datapoollocal/LocalPoolDataSetBase.cpp b/datapoollocal/LocalPoolDataSetBase.cpp index 362e8981..e0fc6b68 100644 --- a/datapoollocal/LocalPoolDataSetBase.cpp +++ b/datapoollocal/LocalPoolDataSetBase.cpp @@ -17,6 +17,9 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, hkManager = hkOwner->getHkManagerHandle(); this->sid.objectId = hkOwner->getObjectId(); this->sid.ownerSetId = setId; + + // Data creators get a periodic helper for periodic HK data generation. + periodicHelper = new PeriodicHousekeepingHelper(this); } LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, diff --git a/datapoollocal/LocalPoolDataSetBase.h b/datapoollocal/LocalPoolDataSetBase.h index 69c71d5a..2f7db9fb 100644 --- a/datapoollocal/LocalPoolDataSetBase.h +++ b/datapoollocal/LocalPoolDataSetBase.h @@ -1,6 +1,7 @@ #ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ #define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ +#include #include "HasLocalDataPoolIF.h" #include "../datapool/DataSetIF.h" #include "../datapool/PoolDataSetBase.h" @@ -33,6 +34,7 @@ class LocalDataPoolManager; */ class LocalPoolDataSetBase: public PoolDataSetBase { friend class LocalDataPoolManager; + friend class PeriodicHousekeepingHelper; public: /** * @brief Constructor for the creator of local pool data. @@ -100,20 +102,19 @@ public: void setValidity(bool valid, bool setEntriesRecursively); bool isValid() const override; - void setIsDiagnostic(bool diagnostics); - bool getIsDiagnostics() const; - protected: sid_t sid; bool isDiagnostics = false; + void setIsDiagnostic(bool diagnostics); + bool getIsDiagnostics() const; - void setReportingEnabled(bool enabled); - bool getReportingEnabled() const; /** * Used for periodic generation. */ - bool reportingEnabled = false; + bool reportingEnabled = false; + void setReportingEnabled(bool enabled); + bool getReportingEnabled() const; /** * If the valid state of a dataset is always relevant to the whole @@ -147,7 +148,7 @@ protected: void bitSetter(uint8_t* byte, uint8_t position) const; bool bitGetter(const uint8_t* byte, uint8_t position) const; private: - + PeriodicHousekeepingHelper* periodicHelper = nullptr; }; diff --git a/housekeeping/HousekeepingSetPacket.h b/housekeeping/HousekeepingSetPacket.h index 9a717420..007b95be 100644 --- a/housekeeping/HousekeepingSetPacket.h +++ b/housekeeping/HousekeepingSetPacket.h @@ -1,13 +1,58 @@ #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ #define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ +#include "../housekeeping/HousekeepingMessage.h" #include "../serialize/SerialLinkedListAdapter.h" +#include "../datapoollocal/LocalPoolDataSetBase.h" class HousekeepingSetPacket: public SerialLinkedListAdapter { +public: + HousekeepingSetPacket(sid_t sid, bool reportingEnabled, bool valid, + float collectionInterval, LocalPoolDataSetBase* dataSetPtr): + objectId(sid.objectId), setId(sid.ownerSetId), + reportingEnabled(reportingEnabled), valid(valid), + collectionIntervalSeconds(collectionInterval), dataSet(dataSetPtr) { + } + ReturnValue_t serialize(uint8_t** buffer, size_t* size, + size_t maxSize, Endianness streamEndianness) const override { + ReturnValue_t result = SerialLinkedListAdapter::serialize(buffer, size, + maxSize, streamEndianness); + if(result != HasReturnvaluesIF::RETURN_OK) { + return result; + } + return dataSet->serializeLocalPoolIds(buffer, size ,maxSize, + streamEndianness); + } + size_t getSerializedSize() const override { + size_t linkedSize = SerialLinkedListAdapter::getSerializedSize(); + linkedSize += dataSet->getFillCount() * sizeof(lp_id_t); + return linkedSize; + } + + ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, + Endianness streamEndianness) override { + return HasReturnvaluesIF::RETURN_OK; + } + +private: + + void setLinks() { + setStart(&objectId); + objectId.setNext(&setId); + setId.setNext(&reportingEnabled); + reportingEnabled.setNext(&valid); + valid.setNext(&collectionIntervalSeconds); + collectionIntervalSeconds.setEnd(); + } + + SerializeElement objectId; + SerializeElement setId; + SerializeElement reportingEnabled; + SerializeElement valid; + SerializeElement collectionIntervalSeconds; + LocalPoolDataSetBase* dataSet; }; - - #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */ diff --git a/housekeeping/PeriodicHousekeepingHelper.cpp b/housekeeping/PeriodicHousekeepingHelper.cpp new file mode 100644 index 00000000..c2ae8126 --- /dev/null +++ b/housekeeping/PeriodicHousekeepingHelper.cpp @@ -0,0 +1,47 @@ +#include "../datapoollocal/LocalPoolDataSetBase.h" +#include "PeriodicHousekeepingHelper.h" +#include + +PeriodicHousekeepingHelper::PeriodicHousekeepingHelper( + LocalPoolDataSetBase* owner): owner(owner) {} + + +void PeriodicHousekeepingHelper::initialize(float collectionInterval, + dur_millis_t minimumPeriodicInterval, bool isDiagnostics, + uint8_t nonDiagIntervalFactor) { + this->minimumPeriodicInterval = minimumPeriodicInterval; + if(not owner->getIsDiagnostics()) { + this->minimumPeriodicInterval = this->minimumPeriodicInterval * + nonDiagIntervalFactor; + } +} + +float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() { + return intervalToIntervalSeconds(collectionIntervalTicks); +} + +bool PeriodicHousekeepingHelper::checkOpNecessary() { + if(internalTickCounter >= collectionIntervalTicks) { + internalTickCounter = 1; + return true; + } + internalTickCounter++; + return false; +} + +uint32_t PeriodicHousekeepingHelper::intervalSecondsToInterval( + float collectionIntervalSeconds) { + return std::ceil(collectionIntervalSeconds * 1000 + / minimumPeriodicInterval); +} + +float PeriodicHousekeepingHelper::intervalToIntervalSeconds( + uint32_t collectionInterval) { + return static_cast(collectionInterval * + minimumPeriodicInterval); +} + +void PeriodicHousekeepingHelper::changeCollectionInterval( + float newIntervalSeconds) { + collectionIntervalTicks = intervalSecondsToInterval(newIntervalSeconds); +} diff --git a/housekeeping/PeriodicHousekeepingHelper.h b/housekeeping/PeriodicHousekeepingHelper.h new file mode 100644 index 00000000..982e8cf6 --- /dev/null +++ b/housekeeping/PeriodicHousekeepingHelper.h @@ -0,0 +1,35 @@ +#ifndef FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ +#define FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ + +#include "../timemanager/Clock.h" +#include + +class LocalPoolDataSetBase; + +class PeriodicHousekeepingHelper { +public: + PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner); + + void initialize(float collectionInterval, + dur_millis_t minimumPeriodicInterval, bool isDiagnostics, + uint8_t nonDiagIntervalFactor); + + void changeCollectionInterval(float newInterval); + float getCollectionIntervalInSeconds(); + bool checkOpNecessary(); +private: + LocalPoolDataSetBase* owner = nullptr; + + + uint32_t intervalSecondsToInterval(float collectionIntervalSeconds); + float intervalToIntervalSeconds(uint32_t collectionInterval); + + dur_millis_t minimumPeriodicInterval = 0; + uint32_t internalTickCounter = 1; + uint32_t collectionIntervalTicks = 0; + +}; + + + +#endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */