eive-obsw/mission/devices/SyrlinksHkHandler.h

#ifndef MISSION_DEVICES_SYRLINKSHKHANDLER_H_
#define MISSION_DEVICES_SYRLINKSHKHANDLER_H_

#include <fsfw/devicehandlers/DeviceHandlerBase.h>
#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
#include <string.h>

/**
 * @brief	This is the device handler for the syrlinks transceiver. It handles the command
 *          transmission and reading of housekeeping data via the housekeeping interface. The
 *          transmission of telemetry and the reception of telecommands is handled by an additional
 *          class.
 *
 * @author	J. Meier
 */
class SyrlinksHkHandler: public DeviceHandlerBase {
public:

	SyrlinksHkHandler(object_id_t objectId, object_id_t comIF,
			CookieIF * comCookie);
	virtual ~SyrlinksHkHandler();

	/**
     * @brief   Sets mode to MODE_NORMAL. Can be used for debugging.
     */
    void setModeNormal();

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;
	LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;

private:

    static const uint8_t INTERFACE_ID = CLASS_ID::SYRLINKS_HANDLER;

    static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
    static const ReturnValue_t UART_FRAMIN_OR_PARITY_ERROR_ACK = MAKE_RETURN_CODE(0xA1);
    static const ReturnValue_t BAD_CHARACTER_ACK = MAKE_RETURN_CODE(0xA2);
    static const ReturnValue_t BAD_PARAMETER_VALUE_ACK = MAKE_RETURN_CODE(0xA3);
    static const ReturnValue_t BAD_END_OF_FRAME_ACK = MAKE_RETURN_CODE(0xA4);
    static const ReturnValue_t UNKNOWN_COMMAND_ID_ACK = MAKE_RETURN_CODE(0xA5);
    static const ReturnValue_t BAD_CRC_ACK = MAKE_RETURN_CODE(0xA6);
    static const ReturnValue_t REPLY_WRONG_SIZE = MAKE_RETURN_CODE(0xA7);
    static const ReturnValue_t MISSING_START_FRAME_CHARACTER = MAKE_RETURN_CODE(0xA8);

	static const uint8_t CRC_INITIAL_VALUE = 0x0;

	std::string resetCommand = "<C04:5A5A:FF41>";
	std::string readRxStatusRegCommand = "<E00::825B>";
	std::string setTxModeStandby = "<W04:4000:7E58>";
	/** W - write, 04 - 4 bytes in data field, 01 - value, 40 register to write value */
	std::string setTxModeModulation = "<W04:4001:4D69>";
	std::string setTxModeCw = "<W04:4010:4968>";
	std::string readTxStatus = "<R02:40:7555>";
	std::string readTxWaveform = "<R02:44:B991>";
	std::string readTxAgcValueHighByte = "<R02:46:DFF3>";
	std::string readTxAgcValueLowByte = "<R02:47:ECC2>";

	/**
	 * In some cases it is not possible to extract from the received reply the information about
	 * the associated command. This variable is thus used to remember the command id.
	 */
	DeviceCommandId_t rememberCommandId = SYRLINKS::NONE;

	SYRLINKS::RxDataset rxDataset;
	SYRLINKS::TxDataset txDataset;

	uint8_t agcValueHighByte;

	uint8_t commandBuffer[SYRLINKS::MAX_COMMAND_SIZE];

	/**
	 * This object is used to store the id of the next command to execute. This controls the
	 * read out of multiple registers which can not be fetched with one single command.
	 */
	DeviceCommandId_t nextCommand = SYRLINKS::READ_RX_STATUS_REGISTERS;

	/**
	 * @brief   This function converts an uint16_t into its hexadecimal string representation.
     *
	 * @param intValue  The value to convert.
	 *
	 * @return  An std::string object containing the hex representation of intValue.
	 */
	std::string convertUint16ToHexString(uint16_t intValue);

	/**
	 * @brief   This function converts a hex number represented by to chars to an 8-bit integer.
	 *
	 * @param twoChars    Pointer to the two characters representing the hex value.
	 *
	 * @details E.g. when twoChars points to an array with the two characters "A5" then the function
	 *          will return 0xA5.
	 * @return  The converted integer.
	 */
	uint8_t convertHexStringToUint8(const char* twoChars);

	/**
	 * @brief   This function converts a hex number represented by 4 chars to an uint16_t.
	 *
	 * @param   Pointer to the fourCharacters representing the 16-bit integer.
	 *
	 * @return  The uint16_t result.
	 */
	uint16_t convertHexStringToUint16(const char* fourChars);

	/**
	 * @brief   Function converts a hex number represented by 6 or 8 characters to an uint32_t.
	 *
	 * @param characters    Pointer to the hex characters array.
	 * @param numberOfChars Number of characters representing the hex value. Must be 6 or 8.
	 *
	 * @return  The uint32_t value.
	 */
	uint32_t convertHexStringToUint32(const char* characters, uint8_t numberOfChars);

	/**
	 * @brief   This function parses the status reply
	 * @param status    Pointer to the status information.
	 *
	 * @details Some commands reply with a status message giving information about the preceding
	 *          command transmission and/or execution was successful.
	 */
	ReturnValue_t parseReplyStatus(const char* status);

	/**
	 * @brief   Function verifies the received reply from the syrlinks by recalculating and
	 *          comparing the crc.
	 *
	 * @param packet    Pointer to the received reply.
	 * @param size  Size of the whole packet including the crc and the packet termination
	 *              character '>'.
	 *
	 * @return  RETURN_OK if successful, otherwise RETURN_FAILED.
	 */
	ReturnValue_t verifyReply(const uint8_t* packet, uint8_t size);

	/**
	 * @brief   This function extracts the data from a rx status registers reply and writes the
	 *          information to the status registers dataset.
	 * @param packet    Pointer to the reply packet.
	 */
	void parseRxStatusRegistersReply(const uint8_t* packet);

	/**
	 * @brief   This function writes the read tx status register to the txStatusDataset.
	 * @param packet    Pointer to the received packet.
	 */
	void parseTxStatusReply(const uint8_t* packet);

	/**
	 * @brief   This function writes the received waveform configuration to the txDataset.
	 */
	void parseTxWaveformReply(const uint8_t* packet);

	/**
	 * @brief   The agc value is split over two registers. The parse agc functions are used to get
	 *          the values from the received reply and write them into the txDataset.
	 */
	void parseAgcLowByte(const uint8_t* packet);
	void parseAgcHighByte(const uint8_t* packet);
};

#endif /* MISSION_DEVICES_SYRLINKSHKHANDLER_H_ */