datapool working

src/fsfw/controller/ControllerBase.cpp

@@ -12,7 +12,10 @@ ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
       mode(MODE_OFF),
       submode(SUBMODE_NONE),
       modeHelper(this),
-      healthHelper(this, setObjectId), actionHelper(this, commandQueue), datapoolHelper(this), housekeepingHelper(this)  {
+      healthHelper(this, setObjectId),
+      actionHelper(this, commandQueue),
+      datapoolHelper(this),
+      housekeepingHelper(this) {
   commandQueue = QueueFactory::instance()->createMessageQueue(commandQueueDepth);
 }
 
@@ -45,7 +48,7 @@ ReturnValue_t ControllerBase::initialize() {
     return result;
   }
 
-  result = actionHelper.initialize();
+  result = actionHelper.initialize(commandQueue);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -120,9 +123,14 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
   return returnvalue::OK;
 }
 
-const ModeHelper * ControllerBase::getModeHelper() const {
+const ModeHelper* ControllerBase::getModeHelper() const { return &modeHelper; }
-  return &modeHelper;
+
-}
+ActionHelper* ControllerBase::getActionHelper() { return &actionHelper; }
+
+ReturnValue_t ControllerBase::executeAction(Action* action) { return action->handle(); }
+
+DatapoolHelper* ControllerBase::getDatapoolHelper() { return &datapoolHelper; }
+HousekeepingHelper* ControllerBase::getHousekeepingHelper() { return &housekeepingHelper; }
 
 void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
 

src/fsfw/datapool/Dataset.cpp

@@ -12,6 +12,7 @@
 Dataset::Dataset(HasDatapoolIF* owner, const EnumIF &id, bool allowUserCommit)
     : HousekeepingSet(owner, id), allocated(true), allowUserCommit(allowUserCommit) {
   this->owner.pointer = owner;
+  owner->getDatapoolHelper()->registerSet(this);
   mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -23,6 +24,7 @@ Dataset::Dataset(uint32_t owner_id, const EnumIF &id)
 Dataset::Dataset(HasDatapoolIF* owner, HousekeepingSetId_t id, bool allowUserCommit)
     : HousekeepingSet(owner, id), allocated(true), allowUserCommit(allowUserCommit) {
   this->owner.pointer = owner;
+  owner->getDatapoolHelper()->registerSet(this);
   mutex = MutexFactory::instance()->createMutex();
 }
 
@@ -92,10 +94,12 @@ ReturnValue_t Dataset::initialize() {
   }
   HasDatapoolIF* actualOwner = ObjectManager::instance()->get<HasDatapoolIF>(owner.id);
   if (actualOwner == nullptr) {
+    puts("owner type");
     return returnvalue::FAILED;
   }
   const Dataset* theOtherSet = actualOwner->getDatapoolHelper()->getDataSet(this->id);
   if (theOtherSet == nullptr) {
+    puts("no set");
     return returnvalue::FAILED;
   }
 

src/fsfw/datapool/DatasetEntry.h

@@ -48,15 +48,15 @@ class DatasetEntry : public Parameter<T>, public DatasetEntryIF {
 
   virtual bool getValid() { return valid; }
 
-  T value; //TODO can this be private?
+  //T value; //TODO can this be private?
 
  protected:
   virtual void commit() {
-    *storedValue = value;
+    *storedValue = Parameter<T>::value;
     *storedValid = valid;
   }
   virtual void read() {
-    value = *storedValue;
+    Parameter<T>::value = *storedValue;
     valid = *storedValid;
   }
 
@@ -70,7 +70,7 @@ class DatasetEntry : public Parameter<T>, public DatasetEntryIF {
     this->storedValid = theOther->storedValid;
   }
 
-  virtual bool changed() { return ((value != *storedValue) || (valid != *storedValid)); }
+  virtual bool changed() { return ((Parameter<T>::value != *storedValue) || (valid != *storedValid)); }
 
  private:
   

src/fsfw/introspection/Parameter.h

@@ -1,15 +1,13 @@
 #pragma once
 
+#include <fsfw/introspection/Types.h>
+#include <fsfw/introspection/TypesHelper.h>
 #include <stdio.h>
 
 #include "HasTmTcParametersIF.h"
-#include <fsfw/introspection/Types.h>
-#include <fsfw/introspection/TypesHelper.h>
 #include "ParameterIF.h"
 // TODO: ifdef introspection stuff
 
-
-
 template <typename T>
 class Parameter : public ParameterIF {
  protected:
@@ -36,9 +34,7 @@ class Parameter : public ParameterIF {
     return enumHelper<std::is_base_of<EnumIF, T>::value>::isValueValid(&value);
   }
 
-  operator T(){
+  operator T() { return value; }
-    return value;
-  }
 
   Parameter &operator=(const T &newValue) {
     value = newValue;
@@ -62,7 +58,8 @@ class Parameter : public ParameterIF {
 
   ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                             Endianness streamEndianness) override {
-    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+    ReturnValue_t result = SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+    return result;
   }
 
 #ifdef FSFW_INTROSPECTION

src/fsfw/modes/ModeHelper.cpp

@@ -110,29 +110,29 @@ void ModeHelper::setForced(bool forced) { this->forced = forced; }
 #ifdef FSFW_INTROSPECTION
 std::vector<std::pair<Mode_t, const char *>> ModeHelper::getModes() const {
   std::vector<std::pair<Mode_t, const char *>> modeVector;
-  auto modeDefinitionHelper = owner->getModeDefinitionHelper();
+  // auto modeDefinitionHelper = owner->getModeDefinitionHelper();
-  EnumIF *mode = modeDefinitionHelper.mode;
+  // EnumIF *mode = modeDefinitionHelper.mode;
-  for (size_t i = 0; i < mode->getSize(); i++) {
+  // for (size_t i = 0; i < mode->getSize(); i++) {
-    modeVector.push_back(
+  //   modeVector.push_back(
-        std::pair<Mode_t, const char *>(mode->getElements()[i], mode->getDescriptions()[i]));
+  //       std::pair<Mode_t, const char *>(mode->getElements()[i], mode->getDescriptions()[i]));
-  }
+  // }
-  modeDefinitionHelper.free();
+  // modeDefinitionHelper.free();
   return modeVector;
 }
 
 std::vector<std::pair<Submode_t, const char *>> ModeHelper::getSubmodes(Mode_t mode) const {
-  auto modeDefinitionHelper = owner->getModeDefinitionHelper();
+  // auto modeDefinitionHelper = owner->getModeDefinitionHelper();
-  EnumIF *submode = modeDefinitionHelper.submode;
+  // EnumIF *submode = modeDefinitionHelper.submode;
   std::vector<std::pair<Submode_t, const char *>> submodeVector;
-  for (size_t i = 0; i < submode->getSize(); i++) {
+  // for (size_t i = 0; i < submode->getSize(); i++) {
-    uint32_t ignored;
+  //   uint32_t ignored;
-    if (owner->checkModeCommand(mode, submode->getElements()[i], &ignored) ==
+  //   if (owner->checkModeCommand(mode, submode->getElements()[i], &ignored) ==
-        returnvalue::OK) {
+  //       returnvalue::OK) {
-      submodeVector.push_back(std::pair<Submode_t, const char *>(submode->getElements()[i],
+  //     submodeVector.push_back(std::pair<Submode_t, const char *>(submode->getElements()[i],
-                                                                 submode->getDescriptions()[i]));
+  //                                                                submode->getDescriptions()[i]));
-    }
+  //   }
-  }
+  // }
-  modeDefinitionHelper.free();
+  // modeDefinitionHelper.free();
   return submodeVector;
 }
 #endif