trying to fuse header / inc

src/fsfw/internalerror/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${LIB_FSFW_NAME} 
+	PRIVATE 
+		InternalErrorReporter.cpp
+)

src/fsfw/internalerror/InternalErrorDataset.h

@@ -0,0 +1,34 @@
+#ifndef FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+#define FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+
+enum errorPoolIds {
+    TM_HITS,
+    QUEUE_HITS,
+    STORE_HITS
+};
+
+
+class InternalErrorDataset: public StaticLocalDataSet<3 * sizeof(uint32_t)> {
+public:
+    static constexpr uint8_t ERROR_SET_ID = 0;
+
+    InternalErrorDataset(HasLocalDataPoolIF* owner):
+            StaticLocalDataSet(owner, ERROR_SET_ID) {}
+
+    InternalErrorDataset(object_id_t objectId):
+           StaticLocalDataSet(sid_t(objectId , ERROR_SET_ID)) {}
+
+    lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId,
+    		TM_HITS, this);
+    lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId,
+    		QUEUE_HITS, this);
+    lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId,
+    		STORE_HITS, this);
+};
+
+
+
+#endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */

src/fsfw/internalerror/InternalErrorReporter.cpp

@@ -0,0 +1,202 @@
+#include "fsfw/internalerror/InternalErrorReporter.h"
+
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/ipc/MutexFactory.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/datapool/PoolReadGuard.h"
+
+InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId,
+        uint32_t messageQueueDepth): SystemObject(setObjectId),
+        commandQueue(QueueFactory::instance()->
+                createMessageQueue(messageQueueDepth)),
+                poolManager(this, commandQueue),
+                internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
+                internalErrorDataset(this) {
+    mutex = MutexFactory::instance()->createMutex();
+}
+
+InternalErrorReporter::~InternalErrorReporter() {
+    MutexFactory::instance()->deleteMutex(mutex);
+}
+
+void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
+    this->diagnosticPrintout = enable;
+}
+
+ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
+    CommandMessage message;
+    ReturnValue_t result = commandQueue->receiveMessage(&message);
+    if(result != MessageQueueIF::EMPTY) {
+        poolManager.handleHousekeepingMessage(&message);
+    }
+
+    uint32_t newQueueHits = getAndResetQueueHits();
+    uint32_t newTmHits = getAndResetTmHits();
+    uint32_t newStoreHits = getAndResetStoreHits();
+
+#if FSFW_VERBOSE_LEVEL >= 1
+    if(diagnosticPrintout) {
+        if((newQueueHits > 0) or (newTmHits > 0) or (newStoreHits > 0)) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::debug << "InternalErrorReporter::performOperation: Errors "
+                    << "occured!" << std::endl;
+            sif::debug << "Queue errors: " << newQueueHits << std::endl;
+            sif::debug << "TM errors: " << newTmHits << std::endl;
+            sif::debug << "Store errors: " << newStoreHits << std::endl;
+#else
+            sif::printDebug("InternalErrorReporter::performOperation: Errors occured!\n");
+            sif::printDebug("Queue errors: %lu\n", static_cast<unsigned int>(newQueueHits));
+            sif::printDebug("TM errors: %lu\n", static_cast<unsigned int>(newTmHits));
+            sif::printDebug("Store errors: %lu\n", static_cast<unsigned int>(newStoreHits));
+#endif
+        }
+    }
+#endif
+
+    {
+        PoolReadGuard readGuard(&internalErrorDataset);
+        if(readGuard.getReadResult() == HasReturnvaluesIF::RETURN_OK) {
+            internalErrorDataset.queueHits.value += newQueueHits;
+            internalErrorDataset.storeHits.value += newStoreHits;
+            internalErrorDataset.tmHits.value += newTmHits;
+            internalErrorDataset.setValidity(true, true);
+        }
+    }
+
+    poolManager.performHkOperation();
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+void InternalErrorReporter::queueMessageNotSent() {
+    incrementQueueHits();
+}
+
+void InternalErrorReporter::lostTm() {
+    incrementTmHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetQueueHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = queueHits;
+    queueHits = 0;
+    mutex->unlockMutex();
+    return value;
+}
+
+uint32_t InternalErrorReporter::getQueueHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = queueHits;
+    mutex->unlockMutex();
+    return value;
+}
+
+void InternalErrorReporter::incrementQueueHits() {
+    mutex->lockMutex(timeoutType, timeoutMs);
+    queueHits++;
+    mutex->unlockMutex();
+}
+
+uint32_t InternalErrorReporter::getAndResetTmHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = tmHits;
+    tmHits = 0;
+    mutex->unlockMutex();
+    return value;
+}
+
+uint32_t InternalErrorReporter::getTmHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = tmHits;
+    mutex->unlockMutex();
+    return value;
+}
+
+void InternalErrorReporter::incrementTmHits() {
+    mutex->lockMutex(timeoutType, timeoutMs);
+    tmHits++;
+    mutex->unlockMutex();
+}
+
+void InternalErrorReporter::storeFull() {
+    incrementStoreHits();
+}
+
+uint32_t InternalErrorReporter::getAndResetStoreHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = storeHits;
+    storeHits = 0;
+    mutex->unlockMutex();
+    return value;
+}
+
+uint32_t InternalErrorReporter::getStoreHits() {
+    uint32_t value;
+    mutex->lockMutex(timeoutType, timeoutMs);
+    value = storeHits;
+    mutex->unlockMutex();
+    return value;
+}
+
+void InternalErrorReporter::incrementStoreHits() {
+    mutex->lockMutex(timeoutType, timeoutMs);
+    storeHits++;
+    mutex->unlockMutex();
+}
+
+object_id_t InternalErrorReporter::getObjectId() const {
+    return SystemObject::getObjectId();
+}
+
+MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
+    return this->commandQueue->getId();
+}
+
+ReturnValue_t InternalErrorReporter::initializeLocalDataPool(
+        localpool::DataPool &localDataPoolMap, LocalDataPoolManager &poolManager) {
+    localDataPoolMap.emplace(errorPoolIds::TM_HITS, new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, new PoolEntry<uint32_t>());
+    localDataPoolMap.emplace(errorPoolIds::STORE_HITS, new PoolEntry<uint32_t>());
+    poolManager.subscribeForPeriodicPacket(internalErrorSid, false, getPeriodicOperationFrequency(),
+            true);
+    internalErrorDataset.setValidity(true, true);
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
+    return this->executingTask->getPeriodMs();
+}
+
+LocalPoolDataSetBase* InternalErrorReporter::getDataSetHandle(sid_t sid) {
+    return &internalErrorDataset;
+}
+
+void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) {
+    this->executingTask = task;
+}
+
+ReturnValue_t InternalErrorReporter::initialize() {
+    ReturnValue_t result = poolManager.initialize(commandQueue);
+    if(result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    return SystemObject::initialize();
+}
+
+ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
+    return poolManager.initializeAfterTaskCreation();
+}
+
+void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+    this->timeoutType = timeoutType;
+    this->timeoutMs = timeoutMs;
+}
+
+LocalDataPoolManager* InternalErrorReporter::getHkManagerHandle() {
+    return &poolManager;
+}

src/fsfw/internalerror/InternalErrorReporter.h

@@ -0,0 +1,95 @@
+#ifndef FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
+#define FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
+
+#include "InternalErrorReporterIF.h"
+
+#include "fsfw/tasks/PeriodicTaskIF.h"
+#include "fsfw/internalerror/InternalErrorDataset.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/ipc/MutexIF.h"
+
+/**
+ * @brief   This class is used to track internal errors like lost telemetry,
+ *          failed message sending or a full store.
+ * @details
+ * All functions were kept virtual so this class can be extended easily
+ * to store custom internal errors (e.g. communication interface errors).
+ */
+class InternalErrorReporter:
+        public SystemObject,
+        public ExecutableObjectIF,
+        public InternalErrorReporterIF,
+        public HasLocalDataPoolIF {
+public:
+
+    InternalErrorReporter(object_id_t setObjectId,
+            uint32_t messageQueueDepth = 5);
+
+    /**
+     * Enable diagnostic printout. Please note that this feature will
+     * only work if DEBUG has been supplied to the build defines.
+     * @param enable
+     */
+    void setDiagnosticPrintout(bool enable);
+
+    void setMutexTimeout(MutexIF::TimeoutType timeoutType,
+            uint32_t timeoutMs);
+
+    virtual ~InternalErrorReporter();
+
+    virtual object_id_t getObjectId() const override;
+    virtual MessageQueueId_t getCommandQueue() const override;
+    virtual ReturnValue_t initializeLocalDataPool(
+            localpool::DataPool& localDataPoolMap,
+            LocalDataPoolManager& poolManager) override;
+    virtual dur_millis_t getPeriodicOperationFrequency() const override;
+    virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+    LocalDataPoolManager* getHkManagerHandle() override;
+
+    virtual ReturnValue_t initialize() override;
+    virtual ReturnValue_t initializeAfterTaskCreation() override;
+    virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+    virtual void queueMessageNotSent();
+
+    virtual void lostTm();
+
+    virtual void storeFull();
+
+    virtual void setTaskIF(PeriodicTaskIF* task) override;
+protected:
+    MessageQueueIF* commandQueue;
+    LocalDataPoolManager poolManager;
+
+    PeriodicTaskIF* executingTask = nullptr;
+
+    MutexIF* mutex = nullptr;
+    MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+    uint32_t timeoutMs = 20;
+
+    sid_t internalErrorSid;
+    InternalErrorDataset internalErrorDataset;
+
+    bool diagnosticPrintout = true;
+
+    uint32_t queueHits = 0;
+    uint32_t tmHits = 0;
+    uint32_t storeHits = 0;
+
+    uint32_t getAndResetQueueHits();
+    uint32_t getQueueHits();
+    void incrementQueueHits();
+
+    uint32_t getAndResetTmHits();
+    uint32_t getTmHits();
+    void incrementTmHits();
+
+    uint32_t getAndResetStoreHits();
+    uint32_t getStoreHits();
+    void incrementStoreHits();
+
+};
+
+#endif /* FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_ */

src/fsfw/internalerror/InternalErrorReporterIF.h

@@ -0,0 +1,27 @@
+#ifndef INTERNALERRORREPORTERIF_H_
+#define INTERNALERRORREPORTERIF_H_
+
+class InternalErrorReporterIF {
+public:
+	virtual ~InternalErrorReporterIF() {
+	}
+
+	/**
+	 * Thread safe
+	 */
+	virtual void queueMessageNotSent() = 0;
+
+	/**
+	 * Thread safe
+	 */
+	virtual void lostTm() = 0;
+
+	/**
+	 * Thread safe
+	 */
+	virtual void storeFull() = 0;
+
+
+};
+
+#endif /* INTERNALERRORREPORTERIF_H_ */