eive-obsw/mission/devices/HeaterHandler.h

#ifndef MISSION_DEVICES_HEATERHANDLER_H_
#define MISSION_DEVICES_HEATERHANDLER_H_

#include <fsfw/objectmanager/SystemObject.h>
#include <fsfw/tasks/ExecutableObjectIF.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/action/HasActionsIF.h>
#include <fsfw/modes/HasModesIF.h>
#include <fsfw/power/PowerSwitchIF.h>
#include <fsfwconfig/devices/heaterSwitcherList.h>

/**
 * @brief	This class intends the control of heaters.
 *
 * @author	J. Meier
 */
class HeaterHandler: public ExecutableObjectIF,
		public PowerSwitchIF,
		public SystemObject,
		public HasActionsIF,
		public HasModesIF,
		public HasReturnvaluesIF {
public:

	/** Device command IDs */
	static const DeviceCommandId_t SWITCH_HEATER;

    HeaterHandler(object_id_t setObjectId, object_id_t gpioDriverId, CookieIF * gpioCookie,
            object_id_t mainLineSwitcherObjectId, uint8_t mainLineSwitch);

    virtual ~HeaterHandler();

	virtual ReturnValue_t performOperation(uint8_t operationCode = 0);

	void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) override;
	virtual void sendFuseOnCommand(uint8_t fuseNr) override;
	/**
	 * @brief	This function will be called from the Heater object to check
	 * 			the current switch state.
	 */
	virtual ReturnValue_t getSwitchState( uint8_t switchNr ) override;
	virtual ReturnValue_t getFuseState( uint8_t fuseNr ) override;
	virtual uint32_t getSwitchDelayMs(void) override;
	ReturnValue_t executeAction(ActionId_t actionId,
			MessageQueueId_t commandedBy, const uint8_t* data, size_t size)
					override;

private:

	static const uint8_t INTERFACE_ID = CLASS_ID::PCDU_HANDLER;

	static const ReturnValue_t COMMAND_NOT_SUPPORTED = MAKE_RETURN_CODE(0xA1);
	static const ReturnValue_t INIT_FAILED = MAKE_RETURN_CODE(0xA2);
	static const ReturnValue_t INVALID_SWITCH_NR = MAKE_RETURN_CODE(0xA3);

	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_HANDLER;
	static const Event GPIO_PULL_HIGH_FAILED = MAKE_EVENT(0, severity::LOW);
	static const Event GPIO_PULL_LOW_FAILED = MAKE_EVENT(1, severity::LOW);
	static const Event SWITCH_ALREADY_ON = MAKE_EVENT(2, severity::LOW);
	static const Event SWITCH_ALREADY_OFF = MAKE_EVENT(3, severity::LOW);

	ReturnValue_t buildCommandFromCommand(
			DeviceCommandId_t deviceCommand, const uint8_t *commandData,
			size_t commandDataLen);
	/**
	 * @brief   Returns the state of a switch (ON - true, or OFF - false).
	 * @param switchNr  The number of the switch to check.
	 */
	bool checkSwitchState(int switchNr);

	/**
	 * @brief   Returns the ID of the GPIO related to a heater identified by the switch number
	 *          which is defined in the heaterSwitches list.
	 */
	gpioId_t getGpioIdFromSwitchNr(switchNr);

	/**
	 * @brief	This function runs commands waiting for execution.
	 */
	void handleActiveCommands();

	ReturnValue_t initializeHeaterMap();

	/**
	 * @brief	Sets all switches to OFF.
	 */
	void setInitialSwitchStates();

	enum SwitchState : bool {
		ON = true,
		OFF = false
	  };


	/**
	 * @brief	Struct holding information about a heater command to execute.
	 *
	 * @param action	The action to perform.
	 * @param replyQueue	The queue of the commander to which status replies
	 * 						will be sent.
	 * @param active	True if command is waiting for execution, otherwise false.
	 */
	typedef struct HeaterCommandInfo {
		uint8_t action;
		MessageQueueId_t replyQueue;
		bool active = false;
	} HeaterCommandInfo_t;

	enum SwitchAction {
		SET_SWITCH_ON,
		SET_SWITCH_OFF
	};

	using switchNr_t = int;
	using HeaterMap = std::unordered_map<switchNr_t, HeaterCommandInfo_t>;
	using HeaterMapIter = HeaterMap::iterator;

	HeateerMap heaterMap;
	HeaterMapIter heaterMapIter;

	bool switchStates[heaterSwitches::NUMBER_OF_SWITCHES];

	/** Size of command queue */
	size_t cmdQueueSize = 20;

	/**
	 * The object ID of the GPIO driver which enables and disables the
	 * heaters.
	 */
	object_id_t gpioDriverId;

	GpioIF* gpioInterface;

	/** Queue to receive messages from other objects. */
	MessageQueueIF* commandQueue = nullptr;

	object_id_t mainLineSwitcherObjectId;

	/** Switch number of the heater power supply switch */
	uint8_t mainLineSwitch;

	/**
	 * Power switcher object which controls the 8V main line of the heater
	 * logic on the TCS board.
	 */
	PowerSwitchIF *mainLineSwitcher = nullptr;

    ActionHelper actionHelper;

    StorageManagerIF *IPCStore = nullptr;
};

#endif /* MISSION_DEVICES_HEATERHANDLER_H_ */