diff --git a/datapoollocal/LocalDataPoolManager.cpp b/datapoollocal/LocalDataPoolManager.cpp index c84b2c69..39434b5a 100644 --- a/datapoollocal/LocalDataPoolManager.cpp +++ b/datapoollocal/LocalDataPoolManager.cpp @@ -177,7 +177,8 @@ const HasLocalDataPoolIF* LocalDataPoolManager::getOwner() const { } ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid, - float collectionInterval, MessageQueueId_t destination) { + /*float collectionInterval, bool reportingEnabled, */ + bool forDownlink, MessageQueueId_t destination) { LocalPoolDataSetBase* dataSetToSerialize = dynamic_cast(owner->getDataSetHandle(sid)); if(dataSetToSerialize == nullptr) { @@ -187,10 +188,13 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid, } store_address_t storeId; - HousekeepingPacketDownlink hkPacket(sid, collectionInterval, - dataSetToSerialize->getFillCount(), dataSetToSerialize); - ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, &storeId); - if(result != HasReturnvaluesIF::RETURN_OK) { + HousekeepingPacketDownlink hkPacket(sid,/* reportingEnabled, + collectionInterval, dataSetToSerialize->getFillCount(), */ + dataSetToSerialize); + size_t serializedSize = 0; + ReturnValue_t result = serializeHkPacketIntoStore(hkPacket, storeId, + forDownlink, &serializedSize); + if(result != HasReturnvaluesIF::RETURN_OK or serializedSize == 0) { return result; } @@ -213,17 +217,21 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid, ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore( HousekeepingPacketDownlink& hkPacket, - store_address_t *storeId) { + store_address_t& storeId, bool forDownlink, + size_t* serializedSize) { uint8_t* dataPtr = nullptr; - size_t serializedSize = 0; const size_t maxSize = hkPacket.getSerializedSize(); - ReturnValue_t result = ipcStore->getFreeElement(storeId, - serializedSize, &dataPtr); + ReturnValue_t result = ipcStore->getFreeElement(&storeId, + maxSize, &dataPtr); if(result != HasReturnvaluesIF::RETURN_OK) { return result; } - return hkPacket.serialize(&dataPtr, &serializedSize, maxSize, + if(forDownlink) { + return hkPacket.serialize(&dataPtr, serializedSize, maxSize, + SerializeIF::Endianness::BIG); + } + return hkPacket.serialize(&dataPtr, serializedSize, maxSize, SerializeIF::Endianness::MACHINE); } @@ -265,7 +273,9 @@ void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver* receiver) { if(receiver->intervalCounter >= receiver->hkParameter.collectionIntervalTicks) { ReturnValue_t result = generateHousekeepingPacket( - receiver->dataId.dataSetSid); + receiver->dataId.dataSetSid, true + /*intervalToIntervalSeconds(receiver->isDiagnostics, + receiver->hkParameter.collectionIntervalTicks), true */); if(result != HasReturnvaluesIF::RETURN_OK) { // configuration error sif::debug << "LocalDataPoolManager::performHkOperation:" diff --git a/datapoollocal/LocalDataPoolManager.h b/datapoollocal/LocalDataPoolManager.h index c6567c80..552aaff7 100644 --- a/datapoollocal/LocalDataPoolManager.h +++ b/datapoollocal/LocalDataPoolManager.h @@ -110,7 +110,8 @@ public: * @return */ ReturnValue_t generateHousekeepingPacket(sid_t sid, - float collectionInterval = 0, + bool forDownlink, + /*float collectionInterval, bool reportingEnabled, */ MessageQueueId_t destination = MessageQueueIF::NO_QUEUE); ReturnValue_t generateSetStructurePacket(sid_t sid); @@ -248,7 +249,7 @@ private: void setMinimalSamplingFrequency(float frequencySeconds); ReturnValue_t serializeHkPacketIntoStore( HousekeepingPacketDownlink& hkPacket, - store_address_t *storeId); + store_address_t& storeId, bool forDownlink, size_t* serializedSize); uint32_t intervalSecondsToInterval(bool isDiagnostics, float collectionIntervalSeconds); diff --git a/globalfunctions/PeriodicOperationDivider.cpp b/globalfunctions/PeriodicOperationDivider.cpp new file mode 100644 index 00000000..ad3b8bbd --- /dev/null +++ b/globalfunctions/PeriodicOperationDivider.cpp @@ -0,0 +1,34 @@ +#include "PeriodicOperationDivider.h" + + +PeriodicOperationDivider::PeriodicOperationDivider(uint32_t divider, + bool resetAutomatically): resetAutomatically(resetAutomatically), + counter(divider), divider(divider) { +} + +bool PeriodicOperationDivider::checkAndIncrement() { + if(counter >= divider) { + if(resetAutomatically) { + counter = 0; + } + return true; + } + counter ++; + return false; +} + +void PeriodicOperationDivider::resetCounter() { + counter = 0; +} + +void PeriodicOperationDivider::setDivider(uint32_t newDivider) { + divider = newDivider; +} + +uint32_t PeriodicOperationDivider::getCounter() const { + return counter; +} + +uint32_t PeriodicOperationDivider::getDivider() const { + return divider; +} diff --git a/globalfunctions/PeriodicOperationDivider.h b/globalfunctions/PeriodicOperationDivider.h new file mode 100644 index 00000000..dd970fb8 --- /dev/null +++ b/globalfunctions/PeriodicOperationDivider.h @@ -0,0 +1,55 @@ +#ifndef FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ +#define FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ + +#include + +/** + * @brief Lightweight helper class to facilitate periodic operation with + * decreased frequencies. + * @details + * This class is useful to perform operations which have to be performed + * with a reduced frequency, like debugging printouts in high periodic tasks + * or low priority operations. + */ +class PeriodicOperationDivider { +public: + /** + * Initialize with the desired divider and specify whether the internal + * counter will be reset automatically. + * @param divider + * @param resetAutomatically + */ + PeriodicOperationDivider(uint32_t divider, bool resetAutomatically = true); + + /** + * Check whether operation is necessary. + * If an operation is necessary and the class has been + * configured to be reset automatically, the counter will be reset. + * If not, the counter will be incremented. + * @return + * -@c true if the counter is larger or equal to the divider + * -@c false otherwise + */ + bool checkAndIncrement(); + + /** + * Can be used to reset the counter to 0 manually. + */ + void resetCounter(); + uint32_t getCounter() const; + + /** + * Can be used to set a new divider value. + * @param newDivider + */ + void setDivider(uint32_t newDivider); + uint32_t getDivider() const; +private: + bool resetAutomatically = true; + uint32_t counter = 0; + uint32_t divider = 0; +}; + + + +#endif /* FSFW_GLOBALFUNCTIONS_PERIODICOPERATIONDIVIDER_H_ */ diff --git a/housekeeping/HousekeepingPacketDownlink.h b/housekeeping/HousekeepingPacketDownlink.h index ee531bae..0be1551d 100644 --- a/housekeeping/HousekeepingPacketDownlink.h +++ b/housekeeping/HousekeepingPacketDownlink.h @@ -2,8 +2,6 @@ #define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ #include "../datapoollocal/LocalPoolDataSetBase.h" - -#include "../housekeeping/HousekeepingMessage.h" #include "../serialize/SerialLinkedListAdapter.h" #include "../storagemanager/StorageManagerIF.h" @@ -16,67 +14,33 @@ */ class HousekeepingPacketDownlink: public SerialLinkedListAdapter { public: - HousekeepingPacketDownlink(sid_t sid, float collectionInterval, uint8_t - numberOfParameters, LocalPoolDataSetBase* dataSetPtr): + HousekeepingPacketDownlink(sid_t sid, /*bool reportingStatus, + float collectionInterval, uint8_t numberOfParameters, */ + LocalPoolDataSetBase* dataSetPtr): sourceId(sid.objectId), setId(sid.ownerSetId), - collectionInterval(collectionInterval), - numberOfParameters(numberOfParameters), hkData(dataSetPtr) { + /*reportingStatus(reportingStatus), + collectionInterval(collectionInterval), + numberOfParameters(numberOfParameters), */hkData(dataSetPtr) { setLinks(); } - /** - * Helper functions which can be used to move HK data from the IPC store - * to the telemetry store. TODO: maybe not needed. - * @param formerStore - * @param storeId - * @param newStore - * @param newStoreId [out] - * @return - */ - virtual ReturnValue_t moveToOtherStore(StorageManagerIF* formerStore, - store_address_t storeId, StorageManagerIF* newStore, - store_address_t* newStoreId) { - const uint8_t* dataPtr = nullptr; - size_t hkDataSize = 0; - ReturnValue_t result = formerStore->getData(storeId, &dataPtr, - &hkDataSize); - if(result != HasReturnvaluesIF::RETURN_OK) { - return result; - } - - return newStore->addData(newStoreId, dataPtr, hkDataSize); - } - private: void setLinks() { setStart(&sourceId); sourceId.setNext(&setId); - setId.setNext(&collectionInterval); - collectionInterval.setNext(&numberOfParameters); - numberOfParameters.setNext(&hkData); + setId.setNext(&hkData); + //setId.setNext(&reportingStatus); + //reportingStatus.setNext(&collectionInterval); + //collectionInterval.setNext(&numberOfParameters); + //numberOfParameters.setNext(&hkData); } SerializeElement sourceId; SerializeElement setId; - SerializeElement collectionInterval; - SerializeElement numberOfParameters; + //SerializeElement reportingStatus; + //SerializeElement collectionInterval; + //SerializeElement numberOfParameters; LinkedElement hkData; }; #endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */ - - - -// virtual 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 dataSetPtr->serialize(buffer, size, maxSize, streamEndianness); -// } -// -// virtual size_t getSerializedSize() const override { -// -// }