From 009139ae50a36aeba137538c028fab963f3a8ed0 Mon Sep 17 00:00:00 2001 From: "Jakob.Meier" <–meierj@irs.uni-stuttgart.de> Date: Thu, 22 Jul 2021 08:06:04 +0200 Subject: [PATCH] ploc supervisor wip --- README.md | 19 +++++ bsp_q7s/core/ObjectFactory.cpp | 21 +++-- linux/fsfwconfig/OBSWConfig.h.in | 6 +- .../pollingSequenceFactory.cpp | 32 ++++++-- mission/devices/PlocSupervisorHandler.cpp | 79 +++++++++++++------ mission/devices/PlocSupervisorHandler.h | 4 + .../PlocSupervisorDefinitions.h | 73 +++++++++++++++++ 7 files changed, 194 insertions(+), 40 deletions(-) diff --git a/README.md b/README.md index 69aa4dc1..787d40f2 100644 --- a/README.md +++ b/README.md @@ -670,3 +670,22 @@ Rebooting currently running image: ```` xsc_boot_copy -r ```` + +## Setting time on Q7S +Setting date and time (only timezone UTC available) +```` +timedatectl set-time 'YYYY-MM-DD HH:MM:SS' +```` +Setting UNIX time +```` +date +%s -s @1626337522 +```` +This only sets the system time and does not updating the time of the real time clock. To harmonize +the system time with the real time clock run +```` +hwclock -w +```` +Reading the real time clock +```` +hwclock --show +```` \ No newline at end of file diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index 6bf90306..91a26d8a 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -171,9 +171,7 @@ void ObjectFactory::produce(void* args){ SpiCookie* spiCookieRadSensor = new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev2.0"), RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED); - RadiationSensorHandler* radsensor = new RadiationSensorHandler(objects::RAD_SENSOR, - objects::SPI_COM_IF, spiCookieRadSensor); - radsensor->setStartUpImmediately(); + new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor); GpioCookie* gpioCookieSus = new GpioCookie(); @@ -404,9 +402,7 @@ void ObjectFactory::produce(void* args){ std::string("/dev/ttyUL0"), UartModes::NON_CANONICAL, 38400, SYRLINKS::MAX_REPLY_SIZE); syrlinksUartCookie->setParityEven(); - SyrlinksHkHandler* syrlinksHkHandler = new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, - objects::UART_COM_IF, syrlinksUartCookie); - syrlinksHkHandler->setModeNormal(); + new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie); #if Q7S_ADD_RTD_DEVICES == 1 GpioCookie* rtdGpioCookie = new GpioCookie; @@ -551,9 +547,11 @@ void ObjectFactory::produce(void* args){ std::string("/dev/i2c-0")); new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie); +#if ADD_PLOC_MPSOC == 1 UartCookie* plocMpsocCookie = new UartCookie(objects::RW1, std::string("/dev/ttyUL3"), UartModes::NON_CANONICAL, 115200, PLOC_MPSOC::MAX_REPLY_SIZE); new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie); +#endif GpioCookie* gpioCookieRw = new GpioCookie; GpioCallback* csRw1 = new GpioCallback(std::string("Chip select reaction wheel 1"), gpio::OUT, @@ -629,6 +627,17 @@ void ObjectFactory::produce(void* args){ new StarTrackerHandler(objects::START_TRACKER, objects::UART_COM_IF, starTrackerCookie); #endif +#if ADD_PLOC_SUPERVISOR == 1 + /* Configuration for MIO0 on TE0720-03-1CFA */ + UartCookie* plocSupervisorCookie = new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, + std::string("/dev/ttyUL3"), UartModes::NON_CANONICAL, 115200, + PLOC_SPV::MAX_REPLY_SIZE); + PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler( + objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie); + plocSupervisor->setStartUpImmediately(); + +#endif + #endif /* TE0720 == 0 */ new UdpTmTcBridge(objects::UDP_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR); diff --git a/linux/fsfwconfig/OBSWConfig.h.in b/linux/fsfwconfig/OBSWConfig.h.in index 4b84b3f1..657b4025 100644 --- a/linux/fsfwconfig/OBSWConfig.h.in +++ b/linux/fsfwconfig/OBSWConfig.h.in @@ -30,8 +30,9 @@ debugging. */ #define TEST_CCSDS_BRIDGE 0 #define PERFORM_PTME_TEST 0 #define ADD_PLOC_SUPERVISOR 1 +#define ADD_PLOC_MPSOC 0 -#define TE0720 1 +#define TE0720 0 #define TE0720_HEATER_TEST 0 #define P60DOCK_DEBUG 0 @@ -42,13 +43,14 @@ debugging. */ #define IMQT_DEBUG 0 #define ADIS16507_DEBUG 1 #define L3GD20_GYRO_DEBUG 0 -#define DEBUG_RAD_SENSOR 1 +#define DEBUG_RAD_SENSOR 0 #define DEBUG_SUS 1 #define DEBUG_RTD 1 #define IMTQ_DEBUG 1 #define RW_DEBUG 0 #define START_TRACKER_DEBUG 0 #define PLOC_MPSOC_DEBUG 1 +#define PLOC_SUPERVISOR_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 a6d35b5e..3771c784 100644 --- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp +++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp @@ -449,8 +449,32 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { // Length of a communication cycle uint32_t length = thisSequence->getPeriodMs(); +#if ADD_PLOC_MPSOC == 1 thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, + DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, + DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, + DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, + DeviceHandlerIF::GET_READ); +#endif + +#if ADD_PLOC_SUPERVISOR == 1 + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0, + DeviceHandlerIF::PERFORM_OPERATION); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2, + DeviceHandlerIF::SEND_WRITE); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, + DeviceHandlerIF::GET_WRITE); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.6, + DeviceHandlerIF::SEND_READ); + thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.8, + DeviceHandlerIF::GET_READ); +#endif + thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION); #if OBSW_ADD_GPS == 1 @@ -460,8 +484,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { DeviceHandlerIF::PERFORM_OPERATION); #endif - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, - DeviceHandlerIF::SEND_WRITE); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE); #if OBSW_ADD_GPS == 1 @@ -471,8 +493,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { DeviceHandlerIF::SEND_WRITE); #endif - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, - DeviceHandlerIF::GET_WRITE); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE); #if OBSW_ADD_GPS == 1 @@ -482,8 +502,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { DeviceHandlerIF::GET_WRITE); #endif - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, - DeviceHandlerIF::SEND_READ); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ); #if OBSW_ADD_GPS == 1 @@ -493,8 +511,6 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) { DeviceHandlerIF::SEND_READ); #endif - thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, - DeviceHandlerIF::GET_READ); thisSequence->addSlot(objects::SYRLINKS_HK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ); #if OBSW_ADD_GPS == 1 diff --git a/mission/devices/PlocSupervisorHandler.cpp b/mission/devices/PlocSupervisorHandler.cpp index 351a0cd9..a075a66c 100644 --- a/mission/devices/PlocSupervisorHandler.cpp +++ b/mission/devices/PlocSupervisorHandler.cpp @@ -62,12 +62,24 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand( prepareSelBootImageCmd(commandData); return RETURN_OK; } + case(PLOC_SPV::RESET_MPSOC): { + prepareEmptyCmd(PLOC_SPV::APID_RESET_MPSOC); + return RETURN_OK; + } case(PLOC_SPV::SET_TIME_REF): { return prepareSetTimeRefCmd(); } case(PLOC_SPV::SET_BOOT_TIMEOUT): { prepareSetBootTimeoutCmd(commandData); return RETURN_OK; + } + case(PLOC_SPV::SET_MAX_RESTART_TRIES): { + prepareRestartTriesCmd(commandData); + return RETURN_OK; + } + case(PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION): { + prepareDisableHk(); + return RETURN_OK; } default: sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented" @@ -87,6 +99,7 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() { this->insertInCommandMap(PLOC_SPV::SET_MAX_RESTART_TRIES); this->insertInCommandMap(PLOC_SPV::RESET_MPSOC); this->insertInCommandMap(PLOC_SPV::SET_TIME_REF); + this->insertInCommandMap(PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION); this->insertInReplyMap(PLOC_SPV::ACK_REPORT, 3, nullptr, PLOC_SPV::SIZE_ACK_REPORT); this->insertInReplyMap(PLOC_SPV::EXE_REPORT, 3, nullptr, PLOC_SPV::SIZE_EXE_REPORT); this->insertInReplyMap(PLOC_SPV::HK_REPORT, 3, nullptr, PLOC_SPV::SIZE_HK_REPORT); @@ -299,29 +312,12 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) { } uint16_t offset = PLOC_SPV::DATA_FIELD_OFFSET; - hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 - | *(data + offset + 3); - offset += 4; hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; - hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 - | *(data + offset + 3); - offset += 4; - hkset.nvm0_1_state = *(data + offset); - offset += 1; - hkset.nvm3_state = *(data + offset); - offset += 1; - hkset.missionIoState = *(data + offset); - offset += 1; - hkset.fmcState = *(data + offset); - offset += 1; - hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 - | *(data + offset + 3); - offset += 4; hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; @@ -334,13 +330,35 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) { hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 | *(data + offset + 3); offset += 4; + hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 + | *(data + offset + 3); + offset += 4; + hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 + | *(data + offset + 3); + offset += 4; + hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 + | *(data + offset + 3); + offset += 4; + hkset.nvm0_1_state = *(data + offset); + offset += 1; + hkset.nvm3_state = *(data + offset); + offset += 1; + hkset.missionIoState = *(data + offset); + offset += 1; + hkset.fmcState = *(data + offset); + offset += 1; nextReplyId = PLOC_SPV::EXE_REPORT; -#if OBSW_VERBOSE_LEVEL >= 1 && PLOC_MPSOC_DEBUG == 1 - sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl; +#if OBSW_VERBOSE_LEVEL >= 1 && PLOC_SUPERVISOR_DEBUG == 1 sif::info << "PlocSupervisorHandler::handleHkReport: temp_ps: " << hkset.tempPs << std::endl; sif::info << "PlocSupervisorHandler::handleHkReport: temp_pl: " << hkset.tempPl << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl; + sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl; sif::info << "PlocSupervisorHandler::handleHkReport: soc_state: " << hkset.socState << std::endl; sif::info << "PlocSupervisorHandler::handleHkReport: nvm0_1_state: " << static_cast(hkset.nvm0_1_state.value) << std::endl; @@ -350,11 +368,7 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) { << static_cast(hkset.missionIoState.value) << std::endl; sif::info << "PlocSupervisorHandler::handleHkReport: fmc_state: " << static_cast(hkset.fmcState.value) << std::endl; - sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl; - sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl; - sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl; - sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl; - sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap << std::endl; + #endif return result; @@ -509,6 +523,14 @@ ReturnValue_t PlocSupervisorHandler::prepareSetTimeRefCmd() { return RETURN_OK; } +void PlocSupervisorHandler::prepareDisableHk() { + PLOC_SPV::DisablePeriodicHkTransmission packet; + memcpy(commandBuffer, packet.getWholeData(), packet.getFullSize()); + rawPacket = commandBuffer; + rawPacketLen = packet.getFullSize(); + nextReplyId = PLOC_SPV::ACK_REPORT; +} + void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t * commandData) { uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 | *(commandData + 3); @@ -519,6 +541,15 @@ void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t * commandData nextReplyId = PLOC_SPV::ACK_REPORT; } +void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t * commandData) { + uint8_t restartTries = *(commandData); + PLOC_SPV::SetRestartTries packet(restartTries); + memcpy(commandBuffer, packet.getWholeData(), packet.getFullSize()); + rawPacket = commandBuffer; + rawPacketLen = packet.getFullSize(); + nextReplyId = PLOC_SPV::ACK_REPORT; +} + void PlocSupervisorHandler::disableAllReplies() { DeviceReplyMap::iterator iter; diff --git a/mission/devices/PlocSupervisorHandler.h b/mission/devices/PlocSupervisorHandler.h index fcbc5a50..400b1873 100644 --- a/mission/devices/PlocSupervisorHandler.h +++ b/mission/devices/PlocSupervisorHandler.h @@ -164,6 +164,8 @@ private: */ void prepareSelBootImageCmd(const uint8_t * commandData); + void prepareDisableHk(); + /** * @brief This function fills the commandBuffer with the data to update the time of the * PLOC supervisor. @@ -176,6 +178,8 @@ private: */ void prepareSetBootTimeoutCmd(const uint8_t * commandData); + void prepareRestartTriesCmd(const uint8_t * commandData); + /** * @brief In case an acknowledgment failure reply has been received this function disables * all previously enabled commands and resets the exepected replies variable of an diff --git a/mission/devices/devicedefinitions/PlocSupervisorDefinitions.h b/mission/devices/devicedefinitions/PlocSupervisorDefinitions.h index 8fffff79..dd4f875b 100644 --- a/mission/devices/devicedefinitions/PlocSupervisorDefinitions.h +++ b/mission/devices/devicedefinitions/PlocSupervisorDefinitions.h @@ -19,6 +19,7 @@ static const DeviceCommandId_t SET_BOOT_TIMEOUT = 6; static const DeviceCommandId_t SET_MAX_RESTART_TRIES = 7; static const DeviceCommandId_t RESET_MPSOC = 8; static const DeviceCommandId_t SET_TIME_REF = 9; +static const DeviceCommandId_t DISABLE_PERIOIC_HK_TRANSMISSION = 10; /** Reply IDs */ static const DeviceCommandId_t ACK_REPORT = 50; @@ -64,6 +65,7 @@ static const uint16_t APID_UPDATE_VERIFY = 0xB2; static const uint16_t APID_WTD_ENABLE = 0xC0; static const uint16_t APID_WTD_CONFIG_TIMEOUT = 0xC1; static const uint16_t APID_SET_TIME_REF = 0xC2; +static const uint16_t APID_DISABLE_HK = 0xC3; static const uint16_t APID_GET_HK_REPORT = 0xC6; @@ -289,6 +291,77 @@ private: } }; +/** + * @brief This class can be used to generate the space packet to set the maximum boot tries. + */ +class SetRestartTries: public SpacePacket { +public: + + /** + * @brief Constructor + * + * @param restartTries Maximum restart tries to set. + */ + SetRestartTries(uint8_t restartTries) : + SpacePacket(DATA_FIELD_LENGTH - 1, true, APID_SET_MAX_RESTART_TRIES, 1), restartTries( + restartTries) { + initPacket(); + } + +private: + + uint8_t restartTries = 0; + + /** Restart tries value (uint8_t) and crc (uint16_t) */ + static const uint16_t DATA_FIELD_LENGTH = 3; + + void initPacket() { + uint8_t* data_field_ptr = this->localData.fields.buffer; + *data_field_ptr = restartTries; + uint16_t crc = CRC::crc16ccitt(this->localData.byteStream, + sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2); + size_t serializedSize = 0; + uint8_t* crcPtr = data_field_ptr + 1; + SerializeAdapter::serialize(&crc, &crcPtr, &serializedSize, sizeof(crc), + SerializeIF::Endianness::BIG); + } +}; + +/** + * @brief With this class the space packet can be generated to disable to periodic transmission + * of housekeeping data. Normally, this will be disabled by default. However, adding this + * command can be useful for debugging. + */ +class DisablePeriodicHkTransmission: public SpacePacket { +public: + + /** + * @brief Constructor + */ + DisablePeriodicHkTransmission() : + SpacePacket(DATA_FIELD_LENGTH - 1, true, APID_DISABLE_HK, 1) { + initPacket(); + } + +private: + + uint8_t disableHk = 0; + + /** Restart tries value (uint8_t) and crc (uint16_t) */ + static const uint16_t DATA_FIELD_LENGTH = 3; + + void initPacket() { + uint8_t* data_field_ptr = this->localData.fields.buffer; + *data_field_ptr = disableHk; + uint16_t crc = CRC::crc16ccitt(this->localData.byteStream, + sizeof(CCSDSPrimaryHeader) + DATA_FIELD_LENGTH - 2); + size_t serializedSize = 0; + uint8_t* crcPtr = data_field_ptr + 1; + SerializeAdapter::serialize(&crc, &crcPtr, &serializedSize, sizeof(crc), + SerializeIF::Endianness::BIG); + } +}; + /** * @brief This dataset to store the housekeeping data of the supervisor. */