From ab15b1ed939d839e85648d1305287e03654c23e1 Mon Sep 17 00:00:00 2001 From: "Jakob.Meier" <–meierj@irs.uni-stuttgart.de> Date: Wed, 7 Jul 2021 12:12:01 +0200 Subject: [PATCH] StarTrackerHandler wip --- .gitmodules | 3 + arcsec-start-tracker | 1 + bsp_q7s/core/ObjectFactory.cpp | 7 + common/config/commonClassIds.h | 1 + common/config/commonObjects.h | 10 +- common/config/commonSubsystemIds.h | 1 + linux/fsfwconfig/OBSWConfig.h.in | 3 +- .../pollingSequenceFactory.cpp | 6 + mission/devices/RwHandler.cpp | 5 +- mission/devices/StarTrackerHandler.cpp | 238 ++++++++++++++++++ mission/devices/StarTrackerHandler.h | 101 ++++++++ .../devices/devicedefinitions/RwDefinitions.h | 2 +- .../StarTrackerDefinitions.h | 64 +++++ 13 files changed, 433 insertions(+), 9 deletions(-) create mode 160000 arcsec-start-tracker create mode 100644 mission/devices/StarTrackerHandler.cpp create mode 100644 mission/devices/StarTrackerHandler.h create mode 100644 mission/devices/devicedefinitions/StarTrackerDefinitions.h diff --git a/.gitmodules b/.gitmodules index 6bde354a..b707a1d4 100644 --- a/.gitmodules +++ b/.gitmodules @@ -19,3 +19,6 @@ [submodule "generators/fsfwgen"] path = generators/fsfwgen url = https://egit.irs.uni-stuttgart.de/fsfw/fsfw-generators.git +[submodule "arcsec-start-tracker"] + path = arcsec-start-tracker + url = https://egit.irs.uni-stuttgart.de/eive/arcsec-start-tracker.git diff --git a/arcsec-start-tracker b/arcsec-start-tracker new file mode 160000 index 00000000..7103370d --- /dev/null +++ b/arcsec-start-tracker @@ -0,0 +1 @@ +Subproject commit 7103370d15c19a843e40dc880a29ace51f348f92 diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index 619e3979..0233672f 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -33,12 +33,14 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include #include @@ -619,6 +621,11 @@ void ObjectFactory::produce(void* args){ gpioIds::EN_RW4); rw4SpiCookie->setCallbackArgs(rwHandler4); + UartCookie* starTrackerCookie = new UartCookie(objects::START_TRACKER, std::string("/dev/ttyUL3"), + UartModes::NON_CANONICAL, 115200, StartTracker::MAX_FRAME_SIZE* 2 + 2); + starTrackerCookie->setNoFixedSizeReply(); + new StarTrackerHandler(objects::START_TRACKER, objects::UART_COM_IF, starTrackerCookie); + #endif /* TE0720 == 0 */ new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR); diff --git a/common/config/commonClassIds.h b/common/config/commonClassIds.h index 8a4a8121..b0cbef75 100644 --- a/common/config/commonClassIds.h +++ b/common/config/commonClassIds.h @@ -14,6 +14,7 @@ enum commonClassIds: uint8_t { SYRLINKS_HANDLER, //SYRLINKS IMTQ_HANDLER, //IMTQ RW_HANDLER, //Reaction Wheels + STR_HANDLER, //Star tracker PLOC_HANDLER, //PLOC SUS_HANDLER, //SUSS CCSDS_IP_CORE_BRIDGE, // IP Core interface diff --git a/common/config/commonObjects.h b/common/config/commonObjects.h index 1fb755e3..a237cbd5 100644 --- a/common/config/commonObjects.h +++ b/common/config/commonObjects.h @@ -73,10 +73,12 @@ enum commonObjects: uint32_t { GPS0_HANDLER = 0x44130045, GPS1_HANDLER = 0x44130146, - RW1 = 0x44210001, - RW2 = 0x44210002, - RW3 = 0x44210003, - RW4 = 0x44210004 + RW1 = 0x44120001, + RW2 = 0x44120002, + RW3 = 0x44120003, + RW4 = 0x44120004, + + START_TRACKER = 0x44130001 }; } diff --git a/common/config/commonSubsystemIds.h b/common/config/commonSubsystemIds.h index bc2fe400..288268c9 100644 --- a/common/config/commonSubsystemIds.h +++ b/common/config/commonSubsystemIds.h @@ -14,6 +14,7 @@ enum: uint8_t { PLOC_HANDLER = 111, IMTQ_HANDLER = 112, RW_HANDLER = 113, + STR_HANDLER = 114, COMMON_SUBSYSTEM_ID_END }; } diff --git a/linux/fsfwconfig/OBSWConfig.h.in b/linux/fsfwconfig/OBSWConfig.h.in index ce1a7526..aca0af91 100644 --- a/linux/fsfwconfig/OBSWConfig.h.in +++ b/linux/fsfwconfig/OBSWConfig.h.in @@ -44,7 +44,8 @@ debugging. */ #define DEBUG_SUS 1 #define DEBUG_RTD 1 #define IMTQ_DEBUG 1 -#define RW_DEBUG 1 +#define RW_DEBUG 0 +#define START_TRACKER_DEBUG 1 // Leave at one as the BSP is linux. Used by the ADIS16507 device handler #define OBSW_ADIS16507_LINUX_COM_IF 1 diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp index 4b201f2b..766efc40 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -504,6 +504,12 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { DeviceHandlerIF::GET_READ); #endif + thisSequence->addSlot(objects::START_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::START_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::START_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::START_TRACKER, length * 0.6, DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::START_TRACKER, length * 0.8, DeviceHandlerIF::GET_READ); + if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) { sif::error << "UART PST initialization failed" << std::endl; return HasReturnvaluesIF::RETURN_FAILED; diff --git a/mission/devices/RwHandler.cpp b/mission/devices/RwHandler.cpp index beb17602..f5b27ad8 100644 --- a/mission/devices/RwHandler.cpp +++ b/mission/devices/RwHandler.cpp @@ -60,7 +60,7 @@ ReturnValue_t RwHandler::buildNormalDeviceCommand(DeviceCommandId_t * id) { internalState = InternalState::GET_RESET_STATUS; break; default: - sif::debug << "RwHandler::buildNormalDeviceCommand: Invalid communication step" + sif::debug << "RwHandler::buildNormalDeviceCommand: Invalid internal step" << std::endl; break; } @@ -176,8 +176,7 @@ ReturnValue_t RwHandler::scanForReply(const uint8_t *start, size_t remainingSize break; } case (static_cast(RwDefinitions::GET_TM)): { -// *foundLen = RwDefinitions::SIZE_GET_TELEMETRY_REPLY; - *foundLen = 91; + *foundLen = RwDefinitions::SIZE_GET_TELEMETRY_REPLY; *foundId = RwDefinitions::GET_TM; break; } diff --git a/mission/devices/StarTrackerHandler.cpp b/mission/devices/StarTrackerHandler.cpp new file mode 100644 index 00000000..c2fefc6a --- /dev/null +++ b/mission/devices/StarTrackerHandler.cpp @@ -0,0 +1,238 @@ +#include "StarTrackerHandler.h" +#include "OBSWConfig.h" + +#include +#include + +#include + +StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, + CookieIF * comCookie, LinuxLibgpioIF* gpioComIF, gpioId_t enableGpio) : + DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this) { + if (comCookie == NULL) { + sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl; + } + slipInit(); +} + +StarTrackerHandler::~StarTrackerHandler() { +} + +void StarTrackerHandler::doStartUp() { + +#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1 + setMode(MODE_NORMAL); +#else + setMode(_MODE_TO_ON); +#endif + +} + +void StarTrackerHandler::doShutDown() { +} + +ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t * id) { + switch (internalState) { + case InternalState::TEMPERATURE_REQUEST: + *id = StartTracker::REQ_TEMPERATURE; + break; + default: + sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid internal step" + << std::endl; + break; + } + return buildCommandFromCommand(*id, NULL, 0); +} + +ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t * id) { + return NOTHING_TO_SEND; +} + +ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, + const uint8_t * commandData, size_t commandDataLen) { + + switch (deviceCommand) { + case (StartTracker::REQ_TEMPERATURE): { + prepareTemperatureRequest(); + return RETURN_OK; + } + default: + return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; + } + return HasReturnvaluesIF::RETURN_FAILED; +} + +void StarTrackerHandler::fillCommandAndReplyMap() { + /** Reply lengths are unknown because of the slip encoding. Thus always maximum reply size + * is specified */ + this->insertInCommandAndReplyMap(StartTracker::REQ_TEMPERATURE, 1, &temperatureSet, + sStartTracker::MAX_FRAME_SIZE * 2 + 2); +} + +ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize, + DeviceCommandId_t *foundId, size_t *foundLen) { + + uint32_t decodedLength = 0; + + for (int i = 0; i < remainingSize; i++) { + enum arc_dec_result decResult = arc_transport_decode_body(*(start + i), &slipInfo, + decodedFrame, &decodedLength); + + switch (decResult) { + case ARC_DEC_INPROGRESS: { + continue; + } + case ARC_DEC_ASYNC: { + sif::debug << "StarTrackerHandler::scanForReply: Received asychronous tm" << std::endl; + /** No asynchronous replies are expected as of now */ + return RETURN_FAILED; + } + case ARC_DEC_ERROR_FRAME_SHORT: + return REPLY_TOO_SHORT; + case ARC_DEC_ERROR_CHECKSUM: + return CRC_FAILURE; + case ARC_DEC_SYNC: { + /** Reset length of SLIP struct for next frame */ + slipInfo.length = 0; + break; + } + default: + sif::debug << "StarTrackerHandler::scanForReply: Unknown result code" << std::endl; + break; + } + } + + switch (*(decodedFrame[1])) { + case (static_cast(StartTracker::REQ_TEMPERATURE)): { + *foundLen = decodedLength; + *foundId = StartTracker::REQ_TEMPERATURE; + break; + } + default: { + sif::debug << "StarTrackerHandler::scanForReply: Reply contains invalid reply id" + << std::endl; + return RETURN_FAILED; + break; + } + } + + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) { + + switch (id) { + case (StartTracker::REQ_TEMPERATURE): { + handleTemperatureTm(); + break; + } + default: { + sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id" << std::endl; + return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; + } + } + + return RETURN_OK; +} + +void StarTrackerHandler::setNormalDatapoolEntriesInvalid() { + +} + +uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { + return 5000; +} + +ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap, + LocalDataPoolManager& poolManager) { + + localDataPoolMap.emplace(RwDefinitions::TEMPERATURE_C, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(RwDefinitions::CURR_SPEED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::REFERENCE_SPEED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::STATE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::CLC_MODE, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(RwDefinitions::LAST_RESET_STATUS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::CURRRENT_RESET_STATUS, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(RwDefinitions::TM_LAST_RESET_STATUS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::TM_MCU_TEMPERATURE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::TM_RW_STATE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::TM_CLC_MODE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::TM_RW_CURR_SPEED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::TM_RW_REF_SPEED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::INVALID_CRC_PACKETS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::INVALID_LEN_PACKETS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::INVALID_CMD_PACKETS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::EXECUTED_REPLIES, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::COMMAND_REPLIES, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_BYTES_WRITTEN, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_BYTES_READ, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_PARITY_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_NOISE_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_FRAME_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_REG_OVERRUN_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::UART_TOTAL_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::SPI_BYTES_WRITTEN, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::SPI_BYTES_READ, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::SPI_REG_OVERRUN_ERRORS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(RwDefinitions::SPI_TOTAL_ERRORS, new PoolEntry( { 0 })); + + return RETURN_OK; +} + +size_t StarTrackerHandler::getNextReplyLength(DeviceCommandId_t commandId){ + return StarTracker::MAX_FRAME_SIZE; +} + +void StarTrackerHandler::slipInit() { + slipInfo.buffer = rxBuffer; + slipInfo.maxlength = StartTracker::MAX_FRAME_SIZE; + slipInfo.length = 0; + slipInfo.unescape_next = 0; + slipInfo.prev_state = SLIP_COMPLETE; +} + +void StarTrackerHandler::prepareTemperatureRequest() { + uint32_t length = 0; + arc_tm_pack_temperature_req(commandBuffer); + uint32_t encLength = 0; + arc_transport_encode_body(commandBuffer, length, encBuffer, &encLength); + rawPacket = encBuffer; + rawPacketLen = encLength; +} + +void StarTrackerHandler::handleTemperatureTm() { + PoolReadGuard rg(&temperatureSet); + uint32_t offset = 1; + temperatureSet.status = *(decodedFrame + offset); + offset += 1; + if(temperatureSet.status.value != 0) { + sif::warning << "StarTrackerHandler::handleTemperatureTm: Reply error: " + << static_const(temperatureSet.status.value) << std::endl; + triggerEvent(TM_REPLY_ERROR, temperatureSet.status.value); + } + temperatureSet.ticks = *(decodedFrame + offset) << 24 + | *(decodedFrame + offset + 1) << 16 | *(decodedFrame + offset + 2) << 8 + | *(decodedFrame + offset + 3); + offset += 4; + temperatureSet.time = *(decodedFrame + offset) << 56 | *(decodedFrame + offset + 1) << 48 + | *(decodedFrame + offset + 2) << 40 | *(decodedFrame + offset + 3) << 32 + | *(decodedFrame + offset + 4) << 24 | *(decodedFrame + offset + 5) << 16 + | *(decodedFrame + offset + 6) << 8 | *(decodedFrame + offset + 7); + offset += 8; + temperatureSet.mcuTemperature = *(decodedFrame + offset) << 24 + | *(decodedFrame + offset + 1) << 16 | *(decodedFrame + offset + 2) << 8 + | *(decodedFrame + offset + 3); + offset += 4; + temperatureSet.cmosTemperature = *(decodedFrame + offset) << 24 + | *(decodedFrame + offset + 1) << 16 | *(decodedFrame + offset + 2) << 8 + | *(decodedFrame + offset + 3); +#if OBSW_VERBOSE_LEVEL >= 1 && START_TRACKER_DEBUG == 1 + sif::info << "StarTrackerHandler::handleTemperatureTm: MCU Temperature: " + << temperatureSet.mcuTemperature << " °C" << std::endl; + sif::info << "StarTrackerHandler::handleTemperatureTm: CMOS Temperature: " + << temperatureSet.mcuTemperature << " °C" << std::endl; +#endif +} diff --git a/mission/devices/StarTrackerHandler.h b/mission/devices/StarTrackerHandler.h new file mode 100644 index 00000000..09478de9 --- /dev/null +++ b/mission/devices/StarTrackerHandler.h @@ -0,0 +1,101 @@ +#ifndef MISSION_DEVICES_STARTRACKERHANDLER_H_ +#define MISSION_DEVICES_STARTRACKERHANDLER_H_ + +#include +#include + +/** + * @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 uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HANDLER; + + //! [EXPORT] : [COMMENT] Result code of tm reply indicates an error + static const ReturnValue_t TM_REPLY_ERROR = MAKE_RETURN_CODE(0xA0); + //! P1: TM id + + LinuxLibgpioIF* gpioComIF = nullptr; + gpioId_t enableGpio = gpio::NO_GPIO; + + StarTracker::TemperatureSet temperatureSet; + + uint8_t commandBuffer[StartTracker::MAX_FRAME_SIZE]; + uint8_t rxBuffer[StartTracker::MAX_FRAME_SIZE]; + uint8_t decodedFrame[StartTracker::MAX_FRAME_SIZE]; + + /** Size of buffer derived from the egse source code */ + uint8_t encBuffer[StartTracker::MAX_FRAME_SIZE * 2 + 2]; + + static slip_decode_state slipInfo = {0}; + + enum class InternalState { + TEMPERATURE_REQUEST + }; + + InternalState internalState = InternalState::TEMPERATURE_REQUEST; + + /** + * @brief This function initializes the serial link ip protocol struct slipInfo. + */ + void slipInit(); + + void prepareTemperatureRequest(DeviceCommandId_t id); + + /** + * @brief This function handles the telemetry reply of a temperature request. + */ + void handleTemperatureTm(); +}; + +#endif /* MISSION_DEVICES_STARTRACKERHANDLER_H_ */ diff --git a/mission/devices/devicedefinitions/RwDefinitions.h b/mission/devices/devicedefinitions/RwDefinitions.h index d87c09fd..83d6456e 100644 --- a/mission/devices/devicedefinitions/RwDefinitions.h +++ b/mission/devices/devicedefinitions/RwDefinitions.h @@ -83,7 +83,7 @@ static const size_t SIZE_GET_RW_STATUS = 14; static const size_t SIZE_SET_SPEED_REPLY = 4; static const size_t SIZE_GET_TEMPERATURE_REPLY = 8; /** Max size when requesting telemetry */ -static const size_t SIZE_GET_TELEMETRY_REPLY = 83; +static const size_t SIZE_GET_TELEMETRY_REPLY = 91; /** Set speed command has maximum size */ static const size_t MAX_CMD_SIZE = 9; diff --git a/mission/devices/devicedefinitions/StarTrackerDefinitions.h b/mission/devices/devicedefinitions/StarTrackerDefinitions.h new file mode 100644 index 00000000..83392e58 --- /dev/null +++ b/mission/devices/devicedefinitions/StarTrackerDefinitions.h @@ -0,0 +1,64 @@ +#ifndef MISSION_STARTRACKER_DEFINITIONS_H_ +#define MISSION_STARTRACKER_DEFINITIONS_H_ + +#include +#include +#include +#include "objects/systemObjectList.h" + +namespace StarTracker { + +/** This is the address of the star tracker */ +static const uint8_t ADDRESS = 33; + +enum PoolIds: lp_id_t { + STATUS, + TICKS, + TIME, + MCU_TEMPERATURE, + CMOS_TEMPERATURE +}; + + + +static const DeviceCommandId_t REQ_TEMPERATURE = 25; + +static const uint32_t TEMPERATURE_SET_ID = REQ_TEMPERATURE; + +/** Max size of unencoded frame */ +static const size_t MAX_FRAME_SIZE = 1200; + +static const uint8_t TEMPERATURE_SET_ENTRIES = 2; + +/** + * @brief This dataset can be used to store the temperature of a reaction wheel. + */ +class TemperatureSet: + public StaticLocalDataSet { +public: + + TemperatureSet(HasLocalDataPoolIF* owner): + StaticLocalDataSet(owner, TEMPERATURE_SET_ID) { + } + + TemperatureSet(object_id_t objectId): + StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) { + } + + lp_var_t status = lp_var_t(sid.objectId, + PoolIds::STATUS, this); + lp_var_t ticks = lp_var_t(sid.objectId, + PoolIds::TICKS, this); + /** Unix time in microseconds */ + lp_var_t ticks = lp_var_t(sid.objectId, + PoolIds::TIME, this); + lp_var_t mcuTemperature = lp_var_t(sid.objectId, + PoolIds::MCU_TEMPERATURE, this); + lp_var_t cmosTemperature = lp_var_t(sid.objectId, + PoolIds::CMOS_TEMPERATURE, this); +}; + +} + +#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */ +