fixed DHB unittest for new Actions

.gitignore

@@ -10,5 +10,8 @@
 .settings
 .metadata
 
+# VSCode
+.vscode
+
 /build*
 /cmake-build*

src/fsfw/CMakeLists.txt

@@ -15,6 +15,7 @@ add_subdirectory(globalfunctions)
 add_subdirectory(health)
 add_subdirectory(housekeeping)
 add_subdirectory(internalerror)
+add_subdirectory(introspection)
 add_subdirectory(ipc)
 add_subdirectory(memory)
 add_subdirectory(modes)

src/fsfw/action/Action.cpp

@@ -0,0 +1,62 @@
+#include "Action.h"
+
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#undef Action
+
+#ifdef FSFW_INTROSPECTION
+
+Action::Action() {}
+
+void Action::setEnum(EnumIF *theEnum) {
+  id = theEnum->getValue();
+  name = theEnum->getDescription();
+}
+
+const char *Action::getName() { return name; }
+#else
+Action::Action(ActionId_t id) : id(id) {}
+#endif
+ActionId_t Action::getId() { return id; }
+
+void Action::registerParameter(ParameterIF *parameter) { parameterList.push_back(parameter); }
+
+std::vector<ParameterIF *> const *Action::getParameters() const { return &parameterList; }
+
+size_t Action::getSerializedSize() const {
+  size_t size = SerializeAdapter::getSerializedSize(&id);
+  for (auto parameter : *getParameters()) {
+    size += parameter->getSerializedSize();
+  }
+  return size;
+}
+
+ReturnValue_t Action::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                Endianness streamEndianness) const {
+  ReturnValue_t result = SerializeAdapter::serialize(&id, buffer, size, maxSize, streamEndianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  for (auto parameter : *getParameters()) {
+    result = parameter->serialize(buffer, size, maxSize, streamEndianness);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t Action::deSerialize(const uint8_t **buffer, size_t *size,
+                                  Endianness streamEndianness) {
+  ReturnValue_t result = returnvalue::OK;/* TODO not needed as must have been read before to find this action = SerializeAdapter::deSerialize(&id, buffer, size, streamEndianness);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }*/
+  for (auto parameter : *getParameters()) {
+    result = parameter->deSerialize(buffer, size, streamEndianness);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  return result;
+}

src/fsfw/action/Action.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <stdint.h>
+
+#include <vector>
+
+#include <fsfw/serialize/SerializeIF.h>
+#include "ActionMessage.h"
+#include "ParameterIF.h"
+
+
+#ifdef FSFW_INTROSPECTION
+#include "../introspection/Enum.h"
+#endif
+
+class Action: public SerializeIF {
+ public:
+#ifdef FSFW_INTROSPECTION
+  Action();
+  void setEnum(EnumIF* id);
+  const char *getName();
+#else
+  Action(ActionId_t id);
+#endif
+  ActionId_t getId();
+
+  MessageQueueId_t commandedBy;
+
+  [[nodiscard]] virtual ReturnValue_t handle() = 0;
+
+  void registerParameter(ParameterIF *parameter);
+
+  std::vector<ParameterIF *> const *getParameters() const;
+
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                  Endianness streamEndianness) const override;
+
+  size_t getSerializedSize() const override;
+
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                                    Endianness streamEndianness) override;
+
+ private:
+  ActionId_t id;
+  
+#ifdef FSFW_INTROSPECTION
+  const char *name;
+#endif
+  std::vector<ParameterIF *> parameterList;
+};

src/fsfw/action/ActionHelper.cpp

@@ -57,6 +57,10 @@ void ActionHelper::finish(bool success, MessageQueueId_t reportTo, ActionId_t co
 
 void ActionHelper::setQueueToUse(MessageQueueIF* queue) { queueToUse = queue; }
 
+MessageQueueIF const * ActionHelper::getQueue() const {
+  return queueToUse;
+}
+
 void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t actionId,
                                     store_address_t dataAddress) {
   const uint8_t* dataPtr = nullptr;
@@ -66,9 +70,29 @@ void ActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId_t act
     CommandMessage reply;
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
     return;
   }
-  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+  auto actionIter = actionMap.find(actionId);
+  if (actionIter == actionMap.end()){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  Action* action = actionIter->second;
+  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
+  if ((result != returnvalue::OK) or (size != 0)){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  //TODO call action->check()
+  action->commandedBy = commandedBy;
+  result = owner->executeAction(action);
   ipcStore->deleteData(dataAddress);
   if (result == HasActionsIF::EXECUTION_FINISHED) {
     CommandMessage reply;
@@ -163,3 +187,11 @@ ReturnValue_t ActionHelper::reportData(MessageQueueId_t reportTo, ActionId_t rep
   }
   return result;
 }
+
+void ActionHelper::registerAction(Action* action) {
+  //TODO error handling
+  ActionId_t id = action->getId();
+  actionMap.emplace(id, action);
+}
+
+std::map<ActionId_t, Action*> const* ActionHelper::getActionMap() { return &actionMap; }

src/fsfw/action/ActionHelper.h

@@ -1,9 +1,13 @@
 #ifndef FSFW_ACTION_ACTIONHELPER_H_
 #define FSFW_ACTION_ACTIONHELPER_H_
 
+#include <map>
+
+#include "Action.h"
 #include "ActionMessage.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/serialize/SerializeIF.h"
+
 /**
  * @brief Action Helper is a helper class which handles action messages
  *
@@ -98,6 +102,16 @@ class ActionHelper {
    */
   void setQueueToUse(MessageQueueIF* queue);
 
+  /**
+   * Needed so templateAction can check if actionHelper was
+   * contructed already to aid in debuggig a nasty coding error.
+   */
+  MessageQueueIF const * getQueue() const;
+
+  void registerAction(Action* action);
+
+  std::map<ActionId_t, Action*> const* getActionMap();
+
  protected:
   //! Increase of value of this per step
   static const uint8_t STEP_OFFSET = 1;
@@ -108,6 +122,8 @@ class ActionHelper {
   MessageQueueIF* queueToUse;
   //! Pointer to an IPC Store, initialized during construction or
   StorageManagerIF* ipcStore = nullptr;
+  //! Map of all implemented Actions
+  std::map<ActionId_t, Action*> actionMap;
 
   /**
    * Internal function called by handleActionMessage

src/fsfw/action/CMakeLists.txt

@@ -1,3 +1,3 @@
 target_sources(
-  ${LIB_FSFW_NAME} PRIVATE ActionHelper.cpp ActionMessage.cpp
+  ${LIB_FSFW_NAME} PRIVATE Action.cpp ActionHelper.cpp ActionMessage.cpp
                            CommandActionHelper.cpp SimpleActionHelper.cpp)

src/fsfw/action/HasActionsIF.h

@@ -44,8 +44,12 @@ class HasActionsIF {
   /**
    * Function to get the MessageQueueId_t of the implementing object
    * @return MessageQueueId_t of the object
+   *
    */
   [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
+
+  [[nodiscard]] virtual ActionHelper* getActionHelper() = 0;
+
   /**
    * Execute or initialize the execution of a certain function.
    * The ActionHelpers will execute this function and behave differently
@@ -55,8 +59,7 @@ class HasActionsIF {
    * -@c EXECUTION_FINISHED Finish reply will be generated
    * -@c Not returnvalue::OK Step failure reply will be generated
    */
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) = 0;
+  virtual ReturnValue_t executeAction(Action* action) = 0;
 };
 
 #endif /* FSFW_ACTION_HASACTIONSIF_H_ */

src/fsfw/action/MinMaxParameter.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "Parameter.h"
+
+template <typename T>
+class MinMaxParameter : public Parameter<T> {
+#ifdef FSFW_INTROSPECTION
+ private:
+  MinMaxParameter(Action *owner, const char *name, T min, T max)
+      : Parameter<T>(owner, name), min(min), max(max) {}
+
+ public:
+  static MinMaxParameter createMinMaxParameter(Action *owner, const char *name, T min, T max) {
+    return MinMaxParameter(owner, name, min, max);
+  }
+  virtual double getMinFloating() override { return static_cast<double>(min); }
+  virtual int64_t getMinSigned() override { return static_cast<int64_t>(min); }
+
+  virtual double getMaxFloating() override { return static_cast<double>(max); }
+  virtual int64_t getMaxSigned() override { return static_cast<int64_t>(max); }
+
+#else
+ private:
+  MinMaxParameter(Action *owner, T min, T max) : Parameter<T>(owner), min(min), max(max) {}
+
+ public:
+  static MinMaxParameter createMinMaxParameter(Action *owner, T min, T max) {
+    return MinMaxParameter(owner, min, max);
+  }
+#endif
+ private:
+  T min;
+  T max;
+};
+
+#ifdef FSFW_INTROSPECTION
+#define createMinMaxParameter(p1, p2, p3, p4) createMinMaxParameter(p1, p2, p3, p4)
+#else
+#define createMinMaxParameter(p1, p2, p3, p4) createMinMaxParameter(p1, p3, p4)
+#endif

src/fsfw/action/Parameter.h

@@ -0,0 +1,120 @@
+#pragma once
+
+#include <stdio.h>
+
+#include "Action.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:
+#ifdef FSFW_INTROSPECTION
+  Parameter(Action *owner, const char *name)
+      : name(name)
+#else
+  Parameter(Action *owner)
+#endif
+  {
+    owner->registerParameter(this);
+  }
+
+ public:
+#ifdef FSFW_INTROSPECTION
+  static Parameter createParameter(Action *owner, const char *name) {
+    return Parameter(owner, name);
+  }
+#else
+  static Parameter createParameter(Action *owner) { return Parameter(owner); }
+#endif
+
+  bool isValid() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::isValid(&value);
+  }
+
+  operator T(){
+    return value;
+  }
+
+  Parameter& operator =(const T& newValue){
+    value = newValue;
+    return *this;
+  }
+
+#ifdef FSFW_INTROSPECTION
+  Types::ParameterType getType() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getType<T>();
+  }
+#endif
+
+  T value;
+
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override {
+    return SerializeAdapter::serialize(&value, buffer, size, maxSize, streamEndianness);
+  }
+
+  size_t getSerializedSize() const override { return SerializeAdapter::getSerializedSize(&value); }
+
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
+    return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+  }
+
+#ifdef FSFW_INTROSPECTION
+  double getFloating() override { return (double)value; }
+  int64_t getSigned() override { return (int64_t)value; }
+
+  bool setFloating(double value) override {
+    if (getType() != Types::FLOATING) {
+      return false;
+    }
+    this->value = T(value);
+    return true;
+  }
+
+  bool setSigned(int64_t value) override {
+    if ((getType() != Types::SIGNED) && (getType() != Types::ENUM)) {
+      return false;
+    }
+    this->value = T(value);
+    return true;
+  }
+
+  double getMinFloating() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMin<T>();
+  }
+  int64_t getMinSigned() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMin<T>();
+  }
+
+  double getMaxFloating() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMax<T>();
+  }
+  int64_t getMaxSigned() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::template getMax<T>();
+  }
+
+  std::vector<int64_t> getEnumValues() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::getEnumValues(&value);
+  }
+  const char *const *getEnumDescriptions() override {
+    return enumHelper<std::is_base_of<EnumIF, T>::value>::getEnumDescriptions(&value);
+  }
+
+  const char *getName() override { return name; }
+
+ private:
+  const char *name;
+#endif
+};
+
+#ifdef FSFW_INTROSPECTION
+#define createParameter(p1, p2) createParameter(p1, p2)
+#else
+#define createParameter(p1, p2) createParameter(p1)
+#endif

src/fsfw/action/ParameterIF.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <fsfw/serialize/SerializeIF.h>
+#include <fsfw/introspection/Types.h>
+
+#ifdef FSFW_INTROSPECTION
+#include <vector>
+#endif
+
+class ParameterIF : public SerializeIF {
+ public:
+  virtual bool isValid() = 0;
+#ifdef FSFW_INTROSPECTION
+
+  
+
+  virtual const char *getName() = 0;
+
+  virtual Types::ParameterType getType() = 0;
+
+  virtual double getFloating() = 0;
+  virtual int64_t getSigned() = 0;
+
+  virtual bool setFloating(double value) = 0;
+  virtual bool setSigned(int64_t value) = 0;
+
+  virtual double getMinFloating() = 0;
+  virtual int64_t getMinSigned() = 0;
+
+  virtual double getMaxFloating() = 0;
+  virtual int64_t getMaxSigned() = 0;
+
+  virtual std::vector<int64_t> getEnumValues() = 0;
+  virtual const char *const * getEnumDescriptions() = 0;
+
+  // ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+  //                                 Endianness streamEndianness) const override = 0;
+
+  // size_t getSerializedSize() const override = 0;
+
+  // ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+  //                                   Endianness streamEndianness) override = 0;
+
+#endif
+};

src/fsfw/action/SimpleActionHelper.cpp

@@ -44,11 +44,27 @@ void SimpleActionHelper::prepareExecution(MessageQueueId_t commandedBy, ActionId
   if (result != returnvalue::OK) {
     ActionMessage::setStepReply(&reply, actionId, 0, result);
     queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  auto actionIter = actionMap.find(actionId);
+  if (actionIter == actionMap.end()){
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_ACTION_ID);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
+    return;
+  }
+  Action* action = actionIter->second;
+  result = action->deSerialize(&dataPtr, &size, SerializeIF::Endianness::NETWORK);
+  if ((result != returnvalue::OK) or (size != 0)) {
+    CommandMessage reply;
+    ActionMessage::setStepReply(&reply, actionId, 0, HasActionsIF::INVALID_PARAMETERS);
+    queueToUse->sendMessage(commandedBy, &reply);
+    ipcStore->deleteData(dataAddress);
     return;
   }
-  lastCommander = commandedBy;
-  lastAction = actionId;
-  result = owner->executeAction(actionId, commandedBy, dataPtr, size);
+  result = action->handle();
   ipcStore->deleteData(dataAddress);
   switch (result) {
     case returnvalue::OK:

src/fsfw/action/TemplateAction.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "Action.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+template <class owner, class action, class ActionEnum>
+class TemplateAction : public Action {
+ public:
+#ifdef FSFW_INTROSPECTION
+  TemplateAction(owner *myOwner, ActionEnum id) : Action(), myOwner(myOwner) {
+    Action::setEnum(&id);
+    if (myOwner->getActionHelper() == nullptr) {
+      sif::error
+          << "TemplateAction::TemplateAction: Action instances need to be created (ie located) after the actionHelper instance."
+          << "Program will segfault now..." << std::endl;
+    }
+    myOwner->getActionHelper()->registerAction(this);
+  }
+#else
+  TemplateAction(owner *myOwner, ActionEnum id) : Action((uint32_t)id), myOwner(myOwner) {
+    myOwner->getActionHelper()->registerAction(this);
+  }
+#endif
+
+  ReturnValue_t handle() override { return myOwner->handleAction(dynamic_cast<action *>(this)); }
+
+ private:
+  owner *myOwner;
+};

src/fsfw/controller/ControllerBase.cpp

@@ -103,6 +103,10 @@ ReturnValue_t ControllerBase::performOperation(uint8_t opCode) {
 
 void ControllerBase::modeChanged(Mode_t mode_, Submode_t submode_) {}
 
+const ModeHelper * ControllerBase::getModeHelper() const {
+  return &modeHelper;
+}
+
 ReturnValue_t ControllerBase::setHealth(HealthState health) {
   switch (health) {
     case HEALTHY:

src/fsfw/controller/ControllerBase.h

@@ -3,6 +3,7 @@
 
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
+#include "fsfw/introspection/ClasslessEnum.h"
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/modes/ModeHelper.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -20,7 +21,9 @@ class ControllerBase : public HasModesIF,
                        public ExecutableObjectIF,
                        public SystemObject {
  public:
-  static const Mode_t MODE_NORMAL = 2;
+  FSFW_CLASSLESS_ENUM(ControllerModes, Mode_t,
+                      ((CONTROLLER_MODE_ON, MODE_ON, "On"))((CONTROLLER_MODE_OFF, MODE_OFF,
+                                                             "Off"))((MODE_NORMAL, 2, "Normal")))
 
   ControllerBase(object_id_t setObjectId, object_id_t parentId, size_t commandQueueDepth = 3);
   ~ControllerBase() override;
@@ -39,6 +42,9 @@ class ControllerBase : public HasModesIF,
   void setTaskIF(PeriodicTaskIF *task) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
+  /** HasModeIF override */
+  const ModeHelper *getModeHelper() const override;
+
  protected:
   /**
    * Implemented by child class. Handle command messages which are not

src/fsfw/controller/ExtendedControllerBase.cpp

@@ -8,11 +8,12 @@ ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, object_id_t
 
 ExtendedControllerBase::~ExtendedControllerBase() = default;
 
-ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
-                                                    MessageQueueId_t commandedBy,
-                                                    const uint8_t *data, size_t size) {
-  /* Needs to be overriden and implemented by child class. */
-  return returnvalue::OK;
+ActionHelper *ExtendedControllerBase::getActionHelper() {
+  return &actionHelper;
+}
+
+ReturnValue_t ExtendedControllerBase::executeAction(Action *action) {
+  return action->handle();
 }
 
 object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); }

src/fsfw/controller/ExtendedControllerBase.h

@@ -29,6 +29,10 @@ class ExtendedControllerBase : public ControllerBase,
   ReturnValue_t performOperation(uint8_t opCode) override;
   ReturnValue_t initializeAfterTaskCreation() override;
 
+  /* HasActionsIF overrides */
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action* actionId) override;
+
  protected:
   LocalDataPoolManager poolManager;
   ActionHelper actionHelper;
@@ -49,10 +53,6 @@ class ExtendedControllerBase : public ControllerBase,
   /* Handle the four messages mentioned above */
   void handleQueue() override;
 
-  /* HasActionsIF overrides */
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
-
   /* HasLocalDatapoolIF overrides */
   LocalDataPoolManager* getHkManagerHandle() override;
   [[nodiscard]] object_id_t getObjectId() const override;

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -1324,21 +1324,21 @@ void DeviceHandlerBase::handleDeviceTm(const SerializeIF& dataSet, DeviceCommand
   }
 }
 
-ReturnValue_t DeviceHandlerBase::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                               const uint8_t* data, size_t size) {
+ActionHelper* DeviceHandlerBase::getActionHelper() { return &actionHelper; }
+
+ReturnValue_t DeviceHandlerBase::executeAction(Action* action) {
   ReturnValue_t result = acceptExternalDeviceCommands();
   if (result != returnvalue::OK) {
     return result;
   }
-  DeviceCommandMap::iterator iter = deviceCommandMap.find(actionId);
-  MessageQueueId_t prevRecipient = MessageQueueIF::NO_QUEUE;
+  DeviceCommandMap::iterator iter = deviceCommandMap.find(action->getId());
   if (iter == deviceCommandMap.end()) {
     result = COMMAND_NOT_SUPPORTED;
   } else if (iter->second.isExecuting) {
     result = COMMAND_ALREADY_SENT;
   } else {
-    iter->second.sendReplyTo = commandedBy;
-    result = buildCommandFromCommand(actionId, data, size);
+    iter->second.sendReplyTo = action->commandedBy;
+    result = action->handle();
   }
   if (result == returnvalue::OK) {
     iter->second.isExecuting = true;
@@ -1602,3 +1602,10 @@ void DeviceHandlerBase::disableCommandsAndReplies() {
     }
   }
 }
+
+ModeHelper const* DeviceHandlerBase::getModeHelper() const { return &modeHelper; }
+
+ModeDefinitionHelper DeviceHandlerBase::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<DeviceHandlerMode, DefaultSubmode>();
+}
+

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -204,13 +204,15 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual void setParentQueue(MessageQueueId_t parentQueueId);
 
-  /** @brief  Implementation required for HasActionIF */
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t *data, size_t size) override;
+  /** @brief  Implementations required for HasActionIF */
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action *action) override;
 
   Mode_t getTransitionSourceMode() const;
   Submode_t getTransitionSourceSubMode() const;
-  virtual void getMode(Mode_t *mode, Submode_t *submode);
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  ModeHelper const * getModeHelper() const override;
+  ModeDefinitionHelper getModeDefinitionHelper() override;
   HealthState getHealth();
   ReturnValue_t setHealth(HealthState health);
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
@@ -314,6 +316,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *    - Anything else triggers an even with the returnvalue as a parameter
    */
   virtual ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) = 0;
+  
+  //TODO Remove and update documentation
   /**
    * @brief 	Build a device command packet from data supplied by a direct
    *          command (PUS Service 8)
@@ -340,7 +344,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                 const uint8_t *commandData,
-                                                size_t commandDataLen) = 0;
+                                                size_t commandDataLen) {return returnvalue::FAILED;}
 
   /* Reply handling */
   /**

src/fsfw/devicehandlers/DeviceHandlerIF.h

@@ -4,6 +4,7 @@
 #include "../action/HasActionsIF.h"
 #include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/Event.h"
+#include "../introspection/ClasslessEnum.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../modes/HasModesIF.h"
 #include "DeviceHandlerMessage.h"
@@ -37,23 +38,30 @@ class DeviceHandlerIF {
    * The mode of the device itself is transparent to the user but related to the mode of the
    * handler. MODE_ON and MODE_OFF are included in hasModesIF.h
    */
+  FSFW_CLASSLESS_ENUM(
+      DeviceHandlerMode, Mode_t,
+      //! The device is powered and ready to perform operations. In this mode, no
+      //! commands are sent by the device handler itself, but direct commands can be
+      //! commanded and will be executed/forwarded to the device
+      //! This is an alias of MODE_ON to have the FSFW_ENUM complete for introspection
+      ((DEVICEHANDLER_MODE_ON, HasModesIF::MODE_ON, "On"))
+      //! The device is powered off. The only command accepted in this
+      //! mode is a mode change to on.
+      //! This is an alias of MODE_OFF to have the FSFW_ENUM complete for introspection
+      ((DEVICEHANDLER_MODE_OFF, HasModesIF::MODE_OFF, "Off"))
+      //! The device is powered on and the device handler periodically sends
+      //! commands. The commands to be sent are selected by the handler
+      //! according to the submode.
+      ((MODE_NORMAL, 2, "Normal"))
+      //! The device is powered on and ready to perform operations. In this mode,
+      //! raw commands can be sent. The device handler will send all replies
+      //! received from the command back to the commanding object as raw TM
+      ((MODE_RAW, 3, "Raw"))
+      //! The device is shut down but the switch could not be turned off, so the
+      //! device still is powered. In this mode, only a mode change to @c MODE_OFF
+      //! can be commanded, which tries to switch off the device again.
+      ((MODE_ERROR_ON, 4, "Error")))
 
-  // MODE_ON = 0, //!< The device is powered and ready to perform operations. In this mode, no
-  // commands are sent by the device handler itself, but direct commands van be commanded and will
-  // be interpreted MODE_OFF = 1, //!< The device is powered off. The only command accepted in this
-  // mode is a mode change to on.
-  //! The device is powered on and the device handler periodically sends
-  //! commands. The commands to be sent are selected by the handler
-  //! according to the submode.
-  static const Mode_t MODE_NORMAL = 2;
-  //! The device is powered on and ready to perform operations. In this mode,
-  //! raw commands can be sent. The device handler will send all replies
-  //! received from the command back to the commanding object.
-  static const Mode_t MODE_RAW = 3;
-  //! The device is shut down but the switch could not be turned off, so the
-  //! device still is powered. In this mode, only a mode change to @c MODE_OFF
-  //! can be commanded, which tries to switch off the device again.
-  static const Mode_t MODE_ERROR_ON = 4;
   //! This is a transitional state which can not be commanded. The device
   //! handler performs all commands to get the device in a state ready to
   //! perform commands. When this is completed, the mode changes to @c MODE_ON.

src/fsfw/introspection/CMakeLists.txt

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

src/fsfw/introspection/ClasslessEnum.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <fsfw/returnvalues/returnvalue.h>
+
+#include <boost/preprocessor.hpp>
+
+// TODO ifdef EnumIF, consistent naming of functions arrays and macros (probably enum values and
+// descriptions)
+
+#include "EnumIF.h"
+#include "EnumCommon.h"
+
+#ifdef FSFW_INTROSPECTION
+
+#define FSFW_CLASSLESS_ENUM(name, type, elements)                                            \
+  enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) };   \
+                                                                                             \
+  class name : public EnumIF {                                                               \
+   public:                                                                                   \
+    enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) }; \
+    name(type value) : value(value) {}                                                       \
+    name() : value(-1) {}                                                                    \
+    name(const name &other) : value(other.value) {}                                          \
+    int64_t getValue() const override { return value; }                                      \
+    operator type() { return value; }                                                        \
+    name &operator=(name other) {                                                            \
+      value = other.value;                                                                   \
+      return *this;                                                                          \
+    }                                                                                        \
+    name &operator=(type value) {                                                            \
+      this->value = value;                                                                   \
+      return *this;                                                                          \
+    }                                                                                        \
+    CREATE_KEY_ARRAY(elements, type)                                                         \
+    VALUE_CHECK(type)                                                                        \
+    GET_INDEX()                                                                              \
+    CREATE_DESCRIPTION_ARRAY(elements)                                                       \
+    GET_DESCRIPTION_FUNC()                                                                   \
+   private:                                                                                  \
+    type value;                                                                              \
+  };
+
+#else
+
+#define FSFW_CLASSLESS_ENUM(name, type, elements) \
+  enum name : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) };
+
+#endif

src/fsfw/introspection/Enum.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#include <boost/preprocessor.hpp>
+
+// TODO ifdef EnumIF, consistent naming of functions arrays and macros (probably enum values and
+// descriptions)
+
+#include "EnumIF.h"
+#include "EnumCommon.h"
+
+
+#ifdef FSFW_INTROSPECTION
+
+#define FSFW_ENUM(name, type, elements)                                                      \
+  class name : public EnumIF, public SerializeIF {                                           \
+   public:                                                                                   \
+    enum : type { BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) }; \
+    name(type value) : value(value) {}                                                       \
+    name() : value(-1) {}                                                                    \
+    name(const name &other) : value(other.value) {}                                          \
+    int64_t getValue() const override { return value; }                                      \
+    operator type() { return value; }                                                        \
+    name &operator=(name other) {                                                            \
+      value = other.value;                                                                   \
+      return *this;                                                                          \
+    }                                                                                        \
+    name &operator=(type value) {                                                            \
+      this->value = value;                                                                   \
+      return *this;                                                                          \
+    }                                                                                        \
+    CREATE_KEY_ARRAY(elements, type)                                                         \
+    VALUE_CHECK(type)                                                                        \
+    GET_INDEX()                                                                              \
+    CREATE_DESCRIPTION_ARRAY(elements)                                                       \
+    GET_DESCRIPTION_FUNC()                                                                   \
+    virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,          \
+                                    Endianness streamEndianness) const override {            \
+      return SerializeAdapter::serialize<>(&value, buffer, size, maxSize, streamEndianness); \
+    }                                                                                        \
+    virtual size_t getSerializedSize() const override {                                      \
+      return SerializeAdapter::getSerializedSize<>(&value);                                  \
+    }                                                                                        \
+    virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,                  \
+                                      Endianness streamEndianness) override {                \
+      return SerializeAdapter::deSerialize<>(&value, buffer, size, streamEndianness);        \
+    }                                                                                        \
+                                                                                             \
+   private:                                                                                  \
+    type value;                                                                              \
+  };
+
+
+#else
+
+#define FSFW_ENUM(name, type, elements)                                     \
+  enum class name : type {                                                  \
+    BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(CLEAN_ENUM_ITEM, "", elements)) \
+  };
+
+
+#endif

src/fsfw/introspection/EnumCommon.h

@@ -0,0 +1,62 @@
+#define CLEAN_ENUM_ITEM(r, data, element)                                          \
+  BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_TUPLE_SIZE(element), 2),                       \
+              (BOOST_PP_TUPLE_ELEM(0, element) = BOOST_PP_TUPLE_ELEM(1, element)), \
+              (BOOST_PP_TUPLE_ELEM(0, element)))
+
+#if defined FSFW_ENUM_VALUE_CHECKS || defined FSFW_INTROSPECTION
+
+
+#define GET_KEY(r, data, element) (BOOST_PP_TUPLE_ELEM(0, element))
+#define GET_DESCRIPTION(r, data, element)                                                       \
+  BOOST_PP_IF(BOOST_PP_SUB(BOOST_PP_TUPLE_SIZE(element), 2), (BOOST_PP_TUPLE_ELEM(2, element)), \
+              (BOOST_PP_TUPLE_ELEM(1, element)))
+
+#define CREATE_KEY_ARRAY(enum_elements, type)                                                \
+  /*was static constexpr, but clang won't compile that*/                                     \
+  int64_t elements[BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements))] = { \
+      BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements))};                 \
+  const int64_t *getElements() const override { return elements; }                           \
+  size_t getSize() const override {                                                          \
+    return BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_KEY, "", enum_elements));             \
+  }
+#define VALUE_CHECK(type)                                                 \
+  bool isValid() const override {                                         \
+    for (size_t i = 0; i < sizeof(elements) / sizeof(elements[0]); i++) { \
+      if (value == elements[i]) {                                         \
+        return true;                                                      \
+      }                                                                   \
+    }                                                                     \
+    return false;                                                         \
+  }
+
+#ifdef FSFW_INTROSPECTION
+#define CREATE_DESCRIPTION_ARRAY(elements)                                                       \
+  /*was static constexpr, but clang won't compile that*/                                         \
+  const char                                                                                     \
+      *descriptions[BOOST_PP_SEQ_SIZE(BOOST_PP_SEQ_FOR_EACH(GET_DESCRIPTION, "", elements))] = { \
+          BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_FOR_EACH(GET_DESCRIPTION, "", elements))};              \
+  const char *const *getDescriptions() const override { return descriptions; }
+#define GET_INDEX()                                                       \
+  size_t getIndex(int64_t value) const override {                         \
+    for (size_t i = 0; i < sizeof(elements) / sizeof(elements[0]); i++) { \
+      if (value == elements[i]) {                                         \
+        return i;                                                         \
+      }                                                                   \
+    }                                                                     \
+    return -1;                                                            \
+  }
+#define GET_DESCRIPTION_FUNC()                        \
+  const char *getDescription() const override {       \
+    if (getIndex(value) == static_cast<size_t>(-1)) { \
+      return nullptr;                                      \
+    } else {                                          \
+      return descriptions[getIndex(value)];           \
+    }                                                 \
+  }
+#else
+#define GET_INDEX()
+#define CREATE_DESCRIPTION_ARRAY(elements)
+#define GET_DESCRIPTION_FUNC()
+#endif
+
+#endif

src/fsfw/introspection/EnumIF.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+class EnumIF {
+ public:
+  virtual ~EnumIF() {}
+  virtual int64_t getValue() const = 0;
+  virtual bool isValid() const = 0;
+  virtual size_t getSize() const = 0;
+  virtual size_t getIndex(int64_t value) const = 0;
+  virtual const int64_t *getElements() const = 0;
+  virtual const char *const *getDescriptions() const = 0;
+  virtual const char *getDescription() const = 0;
+};

src/fsfw/introspection/ParameterTypeSelector.cpp

@@ -0,0 +1,56 @@
+#include "ParameterTypeSelector.h"
+
+#include <stdint.h>
+
+#include "Types.h"
+
+#ifdef FSFW_INTROSPECTION
+
+template <typename T>
+Types::ParameterType ParameterTypeSelector::getType() {
+    return Types::UNSUPPORTED;
+  }
+
+template <>
+Types::ParameterType ParameterTypeSelector::getType<uint8_t>() {
+  return Types::SIGNED;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<int8_t>() {
+  return Types::SIGNED;
+}
+
+template <>
+Types::ParameterType ParameterTypeSelector::getType<uint16_t>() {
+  return Types::SIGNED;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<int16_t>() {
+  return Types::SIGNED;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<uint32_t>() {
+  return Types::SIGNED;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<int32_t>() {
+  return Types::SIGNED;
+}
+// template <>
+// Types::ParameterType ParameterTypeSelector::getType<uint64_t>() {
+//   return Types::UNSIGNED;
+// }
+template <>
+Types::ParameterType ParameterTypeSelector::getType<int64_t>() {
+  return Types::SIGNED;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<float>() {
+  return Types::FLOATING;
+}
+template <>
+Types::ParameterType ParameterTypeSelector::getType<double>() {
+  return Types::FLOATING;
+}
+
+#endif

src/fsfw/introspection/ParameterTypeSelector.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Types.h"
+
+#ifdef FSFW_INTROSPECTION
+
+class ParameterTypeSelector {
+ public:
+  template <typename T>
+  static Types::ParameterType getType();
+};
+
+#endif

src/fsfw/introspection/Types.h

@@ -0,0 +1,8 @@
+#pragma once
+
+//maybe call them MIB types as these are the ones exposed to the MIB?
+// Note: some DBs (Postgress, Mongo) only support signed 64bit integers. To have a common denominator, all integers are int64_t.
+// As such, ther is no unsigned Type, as there can not be a uint64_t and uint32_t completely fits into int64_t
+namespace Types {
+enum ParameterType { SIGNED, FLOATING, ENUM, STRING, BYTEARRAY, UNSUPPORTED };
+}  // namespace Types

src/fsfw/introspection/TypesHelper.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <limits>
+#include <vector>
+
+#include "Enum.h"
+#include "Types.h"
+#include "ParameterTypeSelector.h"
+
+template <bool>
+class enumHelper;
+
+template <>
+class enumHelper<true> {
+ public:
+  static bool isValid(EnumIF *anEnum) { return anEnum->isValid(); }
+
+#ifdef FSFW_INTROSPECTION
+  template <typename T>
+  static Types::ParameterType getType() {
+    return Types::ENUM;
+  }
+
+  template <typename T>
+  static T getMin() {
+    return 0;
+  }
+
+  template <typename T>
+  static T getMax() {
+    return 0;
+  }
+
+  static std::vector<int64_t> getEnumValues() { return std::vector<int64_t>(); }
+
+  static std::vector<int64_t> getEnumValues(EnumIF *anEnum) {
+    std::vector<int64_t> vector;
+    for (size_t i = 0; i < anEnum->getSize(); i++) {
+      vector.push_back(anEnum->getElements()[i]);
+    }
+    return vector;
+  }
+
+  static const char *const *getEnumDescriptions(EnumIF *anEnum) {
+    return anEnum->getDescriptions();
+  }
+#endif
+};
+
+template <>
+class enumHelper<false> {
+ public:
+  static bool isValid(void *) { return true; }
+
+#ifdef FSFW_INTROSPECTION
+  template <typename T>
+  static Types::ParameterType getType() {
+    return ParameterTypeSelector::getType<T>();
+  }
+
+  template <typename T>
+  static T getMin() {
+    return std::numeric_limits<T>::lowest();
+  }
+  template <typename T>
+  static T getMax() {
+    return std::numeric_limits<T>::max();
+  }
+
+  static std::vector<int64_t> getEnumValues(void *) { return std::vector<int64_t>(); }
+
+  static const char *const *getEnumDescriptions(void *) { return nullptr; }
+#endif
+};

src/fsfw/modes/HasModesIF.h

@@ -4,7 +4,9 @@
 #include <cstdint>
 
 #include "../events/Event.h"
+#include "../introspection/ClasslessEnum.h"
 #include "../returnvalues/returnvalue.h"
+#include "ModeDefinitionHelper.h"
 #include "ModeHelper.h"
 #include "ModeMessage.h"
 
@@ -35,7 +37,7 @@ class HasModesIF {
   static const Event MODE_CMD_REJECTED = MAKE_EVENT(7, severity::LOW);
 
   //! The device is powered and ready to perform operations. In this mode, no commands are
-  //! sent by the device handler itself, but direct commands van be commanded and will be
+  //! sent by the device handler itself, but direct commands can be commanded and will be
   //! interpreted
   static constexpr Mode_t MODE_ON = 1;
   //! The device is powered off. The only command accepted in this mode is a mode change to on.
@@ -44,11 +46,14 @@ class HasModesIF {
   static constexpr Mode_t MODE_INVALID = -1;
   static constexpr Mode_t MODE_UNDEFINED = -2;
 
-  //! To avoid checks against magic number "0".
-  static const Submode_t SUBMODE_NONE = 0;
+  FSFW_CLASSLESS_ENUM(DefaultSubmode, Submode_t,
+                      ((SUBMODE_NONE, 0,
+                        "Default")))  //!< To avoid checks against magic number "0".
 
   virtual ~HasModesIF() {}
   virtual MessageQueueId_t getCommandQueue() const = 0;
+  virtual const ModeHelper * getModeHelper() const = 0;
+  virtual ModeDefinitionHelper getModeDefinitionHelper() = 0;
   virtual void getMode(Mode_t *mode, Submode_t *submode) = 0;
 
  protected:

src/fsfw/modes/ModeDefinitionHelper.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <fsfw/introspection/EnumIF.h>
+
+class ModeDefinitionHelper {
+ public:
+#ifdef FSFW_INTROSPECTION
+  ModeDefinitionHelper(EnumIF *mode, EnumIF *submode) : mode(mode), submode(submode) {}
+#else
+  ModeDefinitionHelper(void *mode, void *submode) {};
+#endif
+  template <typename Mode, typename Submode>
+  static ModeDefinitionHelper create() {
+#ifdef FSFW_INTROSPECTION
+    EnumIF *mode = new Mode();
+    EnumIF *submode = new Submode();
+    return ModeDefinitionHelper(mode, submode);
+#else
+    return ModeDefinitionHelper(nullptr, nullptr);
+#endif
+  }
+
+  void free() {
+#ifdef FSFW_INTROSPECTION
+    delete mode;
+    delete submode;
+#endif
+  }
+#ifdef FSFW_INTROSPECTION
+  EnumIF *mode;
+  EnumIF *submode;
+#endif
+};

src/fsfw/modes/ModeHelper.cpp

@@ -4,7 +4,7 @@
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-ModeHelper::ModeHelper(HasModesIF* owner)
+ModeHelper::ModeHelper(HasModesIF *owner)
     : commandedMode(HasModesIF::MODE_OFF),
       commandedSubmode(HasModesIF::SUBMODE_NONE),
       owner(owner),
@@ -12,7 +12,7 @@ ModeHelper::ModeHelper(HasModesIF* owner)
 
 ModeHelper::~ModeHelper() {}
 
-ReturnValue_t ModeHelper::handleModeCommand(CommandMessage* command) {
+ReturnValue_t ModeHelper::handleModeCommand(CommandMessage *command) {
   CommandMessage reply;
   Mode_t mode;
   Submode_t submode;
@@ -106,3 +106,33 @@ bool ModeHelper::isTimedOut() { return countdown.hasTimedOut(); }
 bool ModeHelper::isForced() { return forced; }
 
 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();
+  EnumIF *mode = modeDefinitionHelper.mode;
+  for (size_t i = 0; i < mode->getSize(); i++) {
+    modeVector.push_back(
+        std::pair<Mode_t, const char *>(mode->getElements()[i], mode->getDescriptions()[i]));
+  }
+  modeDefinitionHelper.free();
+  return modeVector;
+}
+
+std::vector<std