eive-obsw/mission/devices/StarTrackerHandler.h

#ifndef MISSION_DEVICES_STARTRACKERHANDLER_H_
#define MISSION_DEVICES_STARTRACKERHANDLER_H_

#include <fsfw/devicehandlers/DeviceHandlerBase.h>
#include <fsfw/src/fsfw/serialize/SerializeAdapter.h>
#include <mission/devices/devicedefinitions/StarTrackerDefinitions.h>
#include <thirdparty/arcsec_star_tracker/common/SLIP.h>
#include <fsfw/datapool/PoolReadGuard.h>

/**
 * @brief	This is the device handler for the star tracker from arcsec.
 *
 * @details Datasheet: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/
 *                     Arbeitsdaten/08_Used%20Components/ArcSec_KULeuven_Startracker/
 *                     Sagitta%201.0%20Datapack&fileid=659181
 * @author	J. Meier
 */
class StarTrackerHandler: public DeviceHandlerBase {
public:

	/**
	 * @brief Constructor
	 *
	 * @param objectId
	 * @param comIF
	 * @param comCookie
	 * @param gpioComIF	Pointer to gpio communication interface
	 * @param enablePin 	GPIO connected to the enable pin of the reaction wheels. Must be pulled
	 * 						to high to enable the device.
	 */
	StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF * comCookie);
	virtual ~StarTrackerHandler();

protected:
	void doStartUp() override;
	void doShutDown() override;
	ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
	ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t * id) override;
	void fillCommandAndReplyMap() override;
	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
				const uint8_t * commandData,size_t commandDataLen) override;
	ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
			DeviceCommandId_t *foundId, size_t *foundLen) override;
	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
			const uint8_t *packet) override;
	void setNormalDatapoolEntriesInvalid() override;
	uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
	ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
            LocalDataPoolManager& poolManager) override;

	/**
	 * @brief   Overwritten here to always read all available data from the UartComIF.
	 */
	virtual size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;

private:

	static const uint8_t INTERFACE_ID = CLASS_ID::STR_HANDLER;

	//! [EXPORT] : [COMMENT] Received reply is too short
    static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB0);
	//! [EXPORT] : [COMMENT] Received reply with invalid CRC
    static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB0);

    static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HANDLER;

    //! [EXPORT] : [COMMENT] Status in temperature reply signals error
    static const ReturnValue_t TEMPERATURE_REQ_FAILED = MAKE_RETURN_CODE(0xA0);
    //! [EXPORT] : [COMMENT] Ping command failed
    static const ReturnValue_t PING_FAILED = MAKE_RETURN_CODE(0xA1);
    //! [EXPORT] : [COMMENT] Status in version reply signals error
    static const ReturnValue_t VERSION_REQ_FAILED = MAKE_RETURN_CODE(0xA3);
    //! [EXPORT] : [COMMENT] Status in interface reply signals error
    static const ReturnValue_t INTERFACE_REQ_FAILED = MAKE_RETURN_CODE(0xA4);
    //! [EXPORT] : [COMMENT] Status in power reply signals error
    static const ReturnValue_t POWER_REQ_FAILED = MAKE_RETURN_CODE(0xA5);
    //! [EXPORT] : [COMMENT] Status of reply to parameter set command signals error
    static const ReturnValue_t SET_PARAM_FAILED = MAKE_RETURN_CODE(0xA6);
    //! [EXPORT] : [COMMENT] Status of reply to action command signals error
    static const ReturnValue_t ACTION_FAILED = MAKE_RETURN_CODE(0xA7);

    static const uint8_t STATUS_OFFSET = 2;
    static const uint8_t TICKS_OFFSET = 3;
    static const uint8_t TIME_OFFSET = 7;
    static const uint8_t TM_DATA_FIELD_OFFSET = 15;
    static const uint8_t PARAMETER_ID_OFFSET = 1;
    static const uint8_t ACTION_ID_OFFSET = 1;

    // Ping request will reply ping with this ID (data field)
    static const uint32_t PING_ID = 0x55;
    static const uint32_t BOOT_REGION_ID = 1;

    static const MutexIF::TimeoutType TIMEOUT_TYPE= MutexIF::TimeoutType::WAITING;
    static const uint32_t MUTEX_TIMEOUT = 20;

    StarTracker::TemperatureSet temperatureSet;
    StarTracker::VersionSet versionSet;
    StarTracker::PowerSet powerSet;
    StarTracker::InterfaceSet interfaceSet;
    StarTracker::TimeSet timeSet;
    StarTracker::SolutionSet solutionSet;

	uint8_t commandBuffer[StarTracker::MAX_FRAME_SIZE];
	uint8_t rxBuffer[StarTracker::MAX_FRAME_SIZE];
	uint8_t decodedFrame[StarTracker::MAX_FRAME_SIZE];

	/** Size of buffer derived from the egse source code */
	uint8_t encBuffer[StarTracker::MAX_FRAME_SIZE * 2 + 2];

	slip_decode_state slipInfo;

	enum class InternalState {
	    TEMPERATURE_REQUEST
    };

	InternalState internalState = InternalState::TEMPERATURE_REQUEST;

	/**
	 * @brief   This function initializes the serial link ip protocol struct slipInfo.
	 */
	void slipInit();

	ReturnValue_t scanForActionReply(DeviceCommandId_t *foundId);
	ReturnValue_t scanForSetParameterReply(DeviceCommandId_t *foundId);
	ReturnValue_t scanForTmReply(DeviceCommandId_t *foundId);

	/**
	 * @brief   Fills command buffer with data to ping the star tracker
	 */
	void preparePingRequest();

	/**
	 * @brief   Fills command buffer with data to request the time telemetry.
	 */
	void prepareTimeRequest();

	/**
	 * @brief   Fills command buffer with data to boot image (works only when star tracker is
	 *          in bootloader mode).
	 */
	void prepareBootCommand();

	/**
	 * @brief   Fills command buffer with data to request the version telemetry packet
	 */
	void prepareVersionRequest();

	/**
	 * @brief   Fills the command buffer with data to request the interface telemetry packet.
	 */
	void prepareInterfaceRequest();

	/**
	 * @brief   Fills the command buffer with data to request the power telemetry packet.
	 */
	void preparePowerRequest();

	/**
	 * @brief   Fills command buffer with data to reboot star tracker.
	 */
	void prepareRebootCommand();

	/**
	 * @brief   Fills command buffer with data to subscribe to a telemetry packet.
	 *
	 * @param tmId  The ID of the telemetry packet to subscribe to
	 */
	void prepareSubscriptionCommand(const uint8_t* tmId);

	/**
     * @brief   Fills command buffer with data to request solution telemtry packet (contains
     *          attitude information)
     */
	void prepareSolutionRequest();

	/**
     * @brief   Fills command buffer with data to request temperature from star tracker
     */
	void prepareTemperatureRequest();

	/**
	 * @brief   Default function to handle action replies
	 */
	ReturnValue_t handleActionReply();

	/**
	 * @brief   Handles all set parameter replies
	 */
	ReturnValue_t handleSetParamReply();

	ReturnValue_t handlePingReply();

	/**
	 * @brief   Fills the time set with the data of the time request reply.
	 */
	ReturnValue_t handleTimeTm();

	/**
	 * @brief   Handles reply data of solution request.
	 */
	ReturnValue_t handleSolutionTm();

	/**
	 * @brief   This function handles the telemetry reply of a temperature request.
	 */
	ReturnValue_t handleTemperatureTm();

	/**
	 * @brief   This function handles the telemetry reply of a version request.
	 */
	ReturnValue_t handleVersionTm();

	/**
	 * @brief   Handles reply to request interface telemetry command.
	 */
	ReturnValue_t handleInterfaceTm();

	/**
	 * @brief   Handles reply to request power telemetry command.
	 */
	ReturnValue_t handlePowerTm();

	/**
	 * @brief   Extracts the header data of a received telemetry frame
	 */
	void getTmHeaderData(uint8_t* status, uint32_t* ticks, uint64_t* time);

	/**
	 * @brief   This function deserializes 8 bytes into a 32 bit unsigned integer.
	 *
	 * @param buffer Pointer to buffer holding the data to deserialize
	 *
	 * @return  The 32-bit unsigned integer.
	 *
	 * @note    Deserialization will be performed in little endian byte order
	 */
	uint32_t deserializeUint32(uint8_t* buffer);

	/**
	 * @brief   This function deserializes 8 bytes into a 64 bit unsigned integer.
	 *
	 * @param buffer Pointer to buffer holding the data to deserialize
	 *
	 * @return  The 64-bit unsigned integer.
	 *
	 * @note    Deserialization will be performed in little endian byte order
	 */
	uint64_t deserializeUint64(uint8_t* buffer);
};

#endif /* MISSION_DEVICES_STARTRACKERHANDLER_H_ */