2023-11-09 10:36:45 +01:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "fsfw/action.h"
|
|
|
|
#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
|
|
|
|
#include "fsfw/datapoollocal/LocalDataPoolManager.h"
|
|
|
|
#include "fsfw/devicehandlers/DeviceHandlerIF.h"
|
2023-11-09 11:04:45 +01:00
|
|
|
#include "fsfw/fdir/FailureIsolationBase.h"
|
2023-11-09 10:36:45 +01:00
|
|
|
#include "fsfw/health/HasHealthIF.h"
|
|
|
|
#include "fsfw/health/HealthHelper.h"
|
|
|
|
#include "fsfw/modes/HasModesIF.h"
|
|
|
|
#include "fsfw/objectmanager.h"
|
|
|
|
#include "fsfw/retval.h"
|
|
|
|
#include "fsfw/subsystem/ModeTreeChildIF.h"
|
|
|
|
#include "fsfw/subsystem/ModeTreeConnectionIF.h"
|
|
|
|
#include "fsfw/tasks/ExecutableObjectIF.h"
|
|
|
|
#include "fsfw/tasks/PeriodicTaskIF.h"
|
|
|
|
|
|
|
|
struct DhbConfig {
|
|
|
|
explicit DhbConfig(object_id_t objectId) : objectId(objectId) {}
|
|
|
|
object_id_t objectId;
|
2023-11-09 11:04:45 +01:00
|
|
|
FailureIsolationBase* fdirInstance = nullptr;
|
|
|
|
object_id_t defaultFdirParent = objects::NO_OBJECT;
|
2023-11-09 10:36:45 +01:00
|
|
|
uint32_t msgQueueDepth = 10;
|
|
|
|
};
|
|
|
|
class FreshDeviceHandlerBase : public SystemObject,
|
|
|
|
public DeviceHandlerIF,
|
|
|
|
public HasModesIF,
|
|
|
|
public HasHealthIF,
|
|
|
|
public ExecutableObjectIF,
|
|
|
|
public ModeTreeChildIF,
|
|
|
|
public ModeTreeConnectionIF,
|
|
|
|
public HasActionsIF,
|
2023-11-09 11:04:45 +01:00
|
|
|
public HasParametersIF,
|
2023-11-09 10:36:45 +01:00
|
|
|
public HasLocalDataPoolIF {
|
|
|
|
public:
|
|
|
|
explicit FreshDeviceHandlerBase(DhbConfig config);
|
2023-11-09 10:45:21 +01:00
|
|
|
~FreshDeviceHandlerBase() override;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Periodic helper executed function, implemented by child class.
|
|
|
|
*/
|
|
|
|
virtual void performDeviceOperation(uint8_t opCode) = 0;
|
2023-11-09 10:36:45 +01:00
|
|
|
|
|
|
|
[[nodiscard]] object_id_t getObjectId() const override;
|
|
|
|
|
|
|
|
[[nodiscard]] MessageQueueId_t getCommandQueue() const override;
|
|
|
|
|
|
|
|
HasHealthIF::HealthState getHealth() override;
|
|
|
|
|
|
|
|
// Mode Tree Overrides.
|
|
|
|
[[nodiscard]] const HasHealthIF* getOptHealthIF() const override;
|
|
|
|
[[nodiscard]] const HasModesIF& getModeIF() const override;
|
|
|
|
ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
|
|
|
|
ModeTreeChildIF& getModeTreeChildIF() override;
|
|
|
|
|
|
|
|
[[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
|
|
|
|
|
|
|
|
protected:
|
2023-11-09 10:45:21 +01:00
|
|
|
// Pool Manager overrides.
|
|
|
|
LocalDataPoolManager* getHkManagerHandle() override;
|
2023-11-09 10:36:45 +01:00
|
|
|
ActionHelper actionHelper;
|
|
|
|
ModeHelper modeHelper;
|
|
|
|
HealthHelper healthHelper;
|
|
|
|
LocalDataPoolManager poolManager;
|
|
|
|
|
2023-11-09 11:04:45 +01:00
|
|
|
bool hasCustomFdir = false;
|
|
|
|
FailureIsolationBase* fdirInstance;
|
|
|
|
object_id_t defaultFdirParent;
|
|
|
|
|
2023-11-09 10:36:45 +01:00
|
|
|
/**
|
|
|
|
* Pointer to the task which executes this component,
|
|
|
|
* is invalid before setTaskIF was called.
|
|
|
|
*/
|
|
|
|
PeriodicTaskIF* executingTask = nullptr;
|
|
|
|
|
|
|
|
Mode_t mode = HasModesIF::MODE_UNDEFINED;
|
|
|
|
Submode_t submode = 0;
|
|
|
|
|
|
|
|
MessageQueueIF* messageQueue;
|
|
|
|
|
2023-11-09 10:45:21 +01:00
|
|
|
virtual ReturnValue_t handleQueue();
|
|
|
|
|
|
|
|
// Mode Helpers.
|
|
|
|
virtual void modeChanged(Mode_t mode, Submode_t submode);
|
2023-11-09 11:28:59 +01:00
|
|
|
/**
|
|
|
|
* The default implementation sets the new mode immediately. If this is not applicable for
|
|
|
|
* certain modes, the user should provide a custom implementation, which performs rougly
|
|
|
|
* the same functionality of this function, when all the steps have been taken to reach the
|
|
|
|
* new mode.
|
|
|
|
*/
|
2023-11-09 10:45:21 +01:00
|
|
|
void startTransition(Mode_t mode, Submode_t submode) override;
|
2023-11-09 17:18:33 +01:00
|
|
|
virtual void setMode(Mode_t newMode, Submode_t newSubmode);
|
|
|
|
virtual void setMode(Mode_t newMode);
|
2023-11-09 10:45:21 +01:00
|
|
|
void getMode(Mode_t* mode, Submode_t* submode) override;
|
|
|
|
void setToExternalControl() override;
|
|
|
|
void announceMode(bool recursive) override;
|
|
|
|
// System Object overrides.
|
|
|
|
ReturnValue_t initialize() override;
|
|
|
|
|
2023-11-09 11:28:59 +01:00
|
|
|
/**
|
|
|
|
* Implemented by child class. Handle all command messages which are
|
|
|
|
* not health, mode, action or housekeeping messages.
|
|
|
|
* @param message
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
|
|
|
|
|
2023-11-09 10:45:21 +01:00
|
|
|
// HK manager abstract functions.
|
|
|
|
LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
|
|
|
|
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
|
|
|
LocalDataPoolManager& poolManager) override = 0;
|
|
|
|
|
|
|
|
// Mode abstract functions
|
|
|
|
ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
|
|
|
|
uint32_t* msToReachTheMode) override = 0;
|
|
|
|
// Health Overrides.
|
|
|
|
ReturnValue_t setHealth(HealthState health) override;
|
|
|
|
// Action override. Forward to user.
|
|
|
|
ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
|
|
|
|
const uint8_t* data, size_t size) override = 0;
|
|
|
|
// Executable overrides.
|
|
|
|
ReturnValue_t performOperation(uint8_t opCode) override;
|
|
|
|
ReturnValue_t initializeAfterTaskCreation() override;
|
|
|
|
|
2023-11-09 11:04:45 +01:00
|
|
|
/**
|
|
|
|
* This calls the FDIR instance event trigger function.
|
|
|
|
* @param event
|
|
|
|
* @param parameter1
|
|
|
|
* @param parameter2
|
|
|
|
*/
|
2023-11-14 11:48:17 +01:00
|
|
|
void triggerEvent(Event event, uint32_t parameter1 = 0, uint32_t parameter2 = 0) override;
|
2023-11-09 11:04:45 +01:00
|
|
|
/**
|
|
|
|
* This calls the FDIR instance event forward function.
|
|
|
|
* @param event
|
|
|
|
* @param parameter1
|
|
|
|
* @param parameter2
|
|
|
|
*/
|
|
|
|
void forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const override;
|
|
|
|
/**
|
|
|
|
* This implementation handles the FDIR parameters. The user can override this to handle
|
|
|
|
* custom parameters.
|
|
|
|
* @param domainId
|
|
|
|
* @param uniqueId
|
|
|
|
* @param parameterWrapper
|
|
|
|
* @param newValues
|
|
|
|
* @param startAtIndex
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
|
|
|
|
const ParameterWrapper* newValues, uint16_t startAtIndex) override;
|
|
|
|
|
2023-11-09 10:45:21 +01:00
|
|
|
private:
|
|
|
|
// Executable Overrides.
|
|
|
|
void setTaskIF(PeriodicTaskIF* task) override;
|
2023-11-09 10:36:45 +01:00
|
|
|
};
|