Merge pull request 'add power switcher component' (#52) from mueller/power-switcher-component into eive/develop

Reviewed-on: #52

hal/src/fsfw_hal/linux/gpio/Gpio.h

@@ -12,16 +12,13 @@
 class Gpio {
  public:
   Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
-      if (gpioIF == nullptr) {
-          sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
-      }
-  }
-  ReturnValue_t pullHigh() {
-      return gpioIF->pullHigh(gpioId);
-  }
-  ReturnValue_t pullLow() {
-      return gpioIF->pullLow(gpioId);
+    if (gpioIF == nullptr) {
+      sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
+    }
   }
+  ReturnValue_t pullHigh() { return gpioIF->pullHigh(gpioId); }
+  ReturnValue_t pullLow() { return gpioIF->pullLow(gpioId); }
+
  private:
   gpioId_t gpioId = gpio::NO_GPIO;
   GpioIF* gpioIF = nullptr;

src/fsfw/action/CommandActionHelper.h

@@ -18,8 +18,7 @@ class CommandActionHelper {
   virtual ~CommandActionHelper();
   ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
                               const uint8_t* data = nullptr, uint32_t size = 0);
-  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId,
-                              SerializeIF* data);
+  ReturnValue_t commandAction(object_id_t commandTo, ActionId_t actionId, SerializeIF* data);
   ReturnValue_t initialize();
   ReturnValue_t handleReply(CommandMessage* reply);
   uint8_t getCommandCount() const;

src/fsfw/devicehandlers/DeviceHandlerBase.cpp

@@ -125,13 +125,14 @@ ReturnValue_t DeviceHandlerBase::initialize() {
     return result;
   }
   if (this->fdirInstance == nullptr) {
-    this->fdirInstance = new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
+    this->fdirInstance =
+        new DeviceHandlerFailureIsolation(this->getObjectId(), defaultFdirParentId);
   }
 
-  if(this->parent != objects::NO_OBJECT) {
+  if (this->parent != objects::NO_OBJECT) {
     HasModesIF* modeIF = ObjectManager::instance()->get<HasModesIF>(this->parent);
     HasHealthIF* healthIF = ObjectManager::instance()->get<HasHealthIF>(this->parent);
-    if(modeIF != nullptr and healthIF != nullptr) {
+    if (modeIF != nullptr and healthIF != nullptr) {
       setParentQueue(modeIF->getCommandQueue());
     }
   }
@@ -361,14 +362,12 @@ void DeviceHandlerBase::doStateMachine() {
       }
     } break;
     case _MODE_WAIT_OFF: {
-      uint32_t currentUptime;
-      Clock::getUptime(&currentUptime);
-
       if (powerSwitcher == nullptr) {
         setMode(MODE_OFF);
         break;
       }
-
+      uint32_t currentUptime;
+      Clock::getUptime(&currentUptime);
       if (currentUptime - timeoutStart >= powerSwitcher->getSwitchDelayMs()) {
         triggerEvent(MODE_TRANSITION_FAILED, PowerSwitchIF::SWITCH_TIMEOUT, 0);
         setMode(MODE_ERROR_ON);
@@ -467,16 +466,15 @@ size_t DeviceHandlerBase::getNextReplyLength(DeviceCommandId_t commandId) {
   DeviceCommandId_t replyId = NO_COMMAND_ID;
   DeviceCommandMap::iterator command = cookieInfo.pendingCommand;
   if (command->second.useAlternativeReplyId) {
-	replyId = command->second.alternativeReplyId;
-  }
-  else {
-	replyId = commandId;
+    replyId = command->second.alternativeReplyId;
+  } else {
+    replyId = commandId;
   }
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
   if (iter != deviceReplyMap.end()) {
-	if (iter->second.delayCycles != 0) {
-		return iter->second.replyLen;
-	}
+    if (iter->second.delayCycles != 0) {
+      return iter->second.replyLen;
+    }
   }
   return 0;
 }
@@ -1522,4 +1520,6 @@ void DeviceHandlerBase::setCustomFdir(FailureIsolationBase* fdir) { this->fdirIn
 
 void DeviceHandlerBase::setParent(object_id_t parent) { this->parent = parent; }
 
-void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) { this->powerSwitcher = switcher; }
+void DeviceHandlerBase::setPowerSwitcher(PowerSwitchIF* switcher) {
+  this->powerSwitcher = switcher;
+}

src/fsfw/devicehandlers/DeviceHandlerBase.h

@@ -103,9 +103,9 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   DeviceHandlerBase(object_id_t setObjectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     FailureIsolationBase *fdirInstance = nullptr, size_t cmdQueueSize = 20);
 
-  void setCustomFdir(FailureIsolationBase* fdir);
+  void setCustomFdir(FailureIsolationBase *fdir);
   void setParent(object_id_t parent);
-  void setPowerSwitcher(PowerSwitchIF* switcher);
+  void setPowerSwitcher(PowerSwitchIF *switcher);
   void setHkDestination(object_id_t hkDestination);
 
   /**

src/fsfw/power/CMakeLists.txt

@@ -4,4 +4,5 @@ target_sources(${LIB_FSFW_NAME} PRIVATE
     PowerSensor.cpp
     PowerSwitcher.cpp
     DummyPowerSwitcher.cpp
+    PowerSwitcherComponent.cpp
 )

src/fsfw/power/PowerSwitchIF.h

@@ -1,7 +1,6 @@
 #ifndef FSFW_POWER_POWERSWITCHIF_H_
 #define FSFW_POWER_POWERSWITCHIF_H_
 
-#include "definitions.h"
 #include "../events/Event.h"
 #include "../returnvalues/HasReturnvaluesIF.h"
 #include "definitions.h"

src/fsfw/power/PowerSwitcher.cpp

@@ -1,4 +1,3 @@
-#include "definitions.h"
 #include "fsfw/power/PowerSwitcher.h"
 
 #include "definitions.h"

src/fsfw/power/PowerSwitcherComponent.cpp

@@ -0,0 +1,108 @@
+#include "PowerSwitcherComponent.h"
+
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/power/PowerSwitchIF.h>
+
+PowerSwitcherComponent::PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF* pwrSwitcher, power::Switch_t pwrSwitch)
+  : SystemObject(objectId), switcher(pwrSwitcher, pwrSwitch), modeHelper(this),
+    healthHelper(this, objectId) {
+  queue = QueueFactory::instance()->createMessageQueue();
+}
+
+ReturnValue_t PowerSwitcherComponent::performOperation(uint8_t opCode) {
+  ReturnValue_t result;
+  CommandMessage command;
+
+  for (result = queue->receiveMessage(&command); result == RETURN_OK;
+       result = queue->receiveMessage(&command)) {
+    result = healthHelper.handleHealthCommand(&command);
+    if (result == RETURN_OK) {
+      continue;
+    }
+
+    result = modeHelper.handleModeCommand(&command);
+    if (result == RETURN_OK) {
+      continue;
+    }
+  }
+  if(switcher.active()) {
+    switcher.doStateMachine();
+    auto currState = switcher.getState();
+    if (currState == PowerSwitcher::SWITCH_IS_OFF) {
+      setMode(MODE_OFF, 0);
+    } else if(currState == PowerSwitcher::SWITCH_IS_ON) {
+      setMode(MODE_ON, 0);
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherComponent::initialize() {
+  ReturnValue_t result = modeHelper.initialize();
+  if(result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = healthHelper.initialize();
+  if(result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return SystemObject::initialize();
+}
+
+MessageQueueId_t PowerSwitcherComponent::getCommandQueue() const {
+  return queue->getId();
+}
+
+void PowerSwitcherComponent::getMode(Mode_t *mode, Submode_t *submode) {
+  *mode = this->mode;
+  *submode = this->submode;
+}
+
+ReturnValue_t PowerSwitcherComponent::setHealth(HealthState health) {
+  healthHelper.setHealth(health);
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherComponent::checkModeCommand(Mode_t mode, Submode_t submode,
+    uint32_t *msToReachTheMode) {
+  *msToReachTheMode = 5000;
+  if(mode != MODE_ON and mode != MODE_OFF) {
+    return TRANS_NOT_ALLOWED;
+  }
+  return RETURN_OK;
+}
+
+void PowerSwitcherComponent::startTransition(Mode_t mode, Submode_t submode) {
+  if(mode == MODE_OFF) {
+    switcher.turnOff(true);
+    switcher.doStateMachine();
+    if(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF) {
+      setMode(MODE_OFF, 0);
+    }
+  } else if (mode == MODE_ON) {
+    switcher.turnOn(true);
+    switcher.doStateMachine();
+    if(switcher.getState() == PowerSwitcher::SWITCH_IS_ON) {
+      setMode(MODE_ON, 0);
+    }
+  }
+}
+
+void PowerSwitcherComponent::setToExternalControl() {
+  healthHelper.setHealth(HasHealthIF::EXTERNAL_CONTROL);
+}
+
+void PowerSwitcherComponent::announceMode(bool recursive) {
+  triggerEvent(MODE_INFO, mode, submode);
+}
+
+void PowerSwitcherComponent::setMode(Mode_t newMode, Submode_t newSubmode) {
+  this->mode = newMode;
+  this->submode = newSubmode;
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}
+
+HasHealthIF::HealthState PowerSwitcherComponent::getHealth() {
+  return healthHelper.getHealth();
+}

src/fsfw/power/PowerSwitcherComponent.h

@@ -0,0 +1,64 @@
+#ifndef _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
+#define _FSFW_POWER_POWERSWITCHERCOMPONENT_H_
+
+#include <fsfw/health/HasHealthIF.h>
+#include <fsfw/health/HealthHelper.h>
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/modes/ModeHelper.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/power/definitions.h>
+#include <fsfw/power/PowerSwitcher.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+
+class PowerSwitchIF;
+
+/**
+ * @brief Allows to create an power switch object with its own mode and health
+ * @details
+ * This basic component allows to create an object which is solely responsible for managing a
+ * switch. It also has a mode and a health by implementing the respective interface components
+ * which allows integrating this component into a system mode tree.
+ *
+ * Commanding this component to MODE_OFF will cause the switcher to turn the switch off while
+ * commanding in to MODE_ON will cause the switcher to turn the switch on.
+ */
+class PowerSwitcherComponent:
+    public SystemObject,
+    public HasReturnvaluesIF,
+    public ExecutableObjectIF,
+    public HasModesIF,
+    public HasHealthIF {
+public:
+  PowerSwitcherComponent(object_id_t objectId, PowerSwitchIF* pwrSwitcher,
+      power::Switch_t pwrSwitch);
+
+private:
+
+  MessageQueueIF* queue = nullptr;
+  PowerSwitcher switcher;
+
+  Mode_t mode = MODE_OFF;
+  Submode_t submode = 0;
+
+  ModeHelper modeHelper;
+  HealthHelper healthHelper;
+
+  void setMode(Mode_t newMode, Submode_t newSubmode);
+
+  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+
+  ReturnValue_t initialize() override;
+
+  MessageQueueId_t getCommandQueue() const override;
+  void getMode(Mode_t *mode, Submode_t *submode) override;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                         uint32_t *msToReachTheMode) override;
+  void startTransition(Mode_t mode, Submode_t submode) override;
+  void setToExternalControl() override;
+  void announceMode(bool recursive) override;
+
+  ReturnValue_t setHealth(HealthState health) override;
+  HasHealthIF::HealthState getHealth() override;
+};
+
+#endif /* _FSFW_POWER_POWERSWITCHERCOMPONENT_H_ */