From 1b00029202bce4f196621b974ff43aaf70d06b22 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 7 Mar 2023 18:16:35 +0100 Subject: [PATCH 1/7] move those json thingies into the header --- linux/devices/startracker/StarTrackerHandler.cpp | 16 ++-------------- linux/devices/startracker/StarTrackerHandler.h | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 14 deletions(-) diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index a868a22b..77ff9156 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -1,6 +1,7 @@ #include "StarTrackerHandler.h" #include +#include #include @@ -419,7 +420,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return returnvalue::OK; } case (startracker::SUBSCRIPTION): { - Subscription subscription; result = prepareParamCommand(commandData, commandDataLen, subscription); return returnvalue::OK; } @@ -436,67 +436,54 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return returnvalue::OK; } case (startracker::LIMITS): { - Limits limits; result = prepareParamCommand(commandData, commandDataLen, limits); return result; } case (startracker::MOUNTING): { - Mounting mounting; result = prepareParamCommand(commandData, commandDataLen, mounting); return result; } case (startracker::IMAGE_PROCESSOR): { - ImageProcessor imageProcessor; result = prepareParamCommand(commandData, commandDataLen, imageProcessor); return result; } case (startracker::CAMERA): { - Camera camera; result = prepareParamCommand(commandData, commandDataLen, camera); return result; } case (startracker::CENTROIDING): { - Centroiding centroiding; result = prepareParamCommand(commandData, commandDataLen, centroiding); return result; } case (startracker::LISA): { - Lisa lisa; result = prepareParamCommand(commandData, commandDataLen, lisa); return result; } case (startracker::MATCHING): { - Matching matching; result = prepareParamCommand(commandData, commandDataLen, matching); return result; } case (startracker::VALIDATION): { - Validation validation; result = prepareParamCommand(commandData, commandDataLen, validation); return result; } case (startracker::ALGO): { - Algo algo; result = prepareParamCommand(commandData, commandDataLen, algo); return result; } case (startracker::TRACKING): { - Tracking tracking; result = prepareParamCommand(commandData, commandDataLen, tracking); return result; } case (startracker::LOGLEVEL): { - LogLevel logLevel; result = prepareParamCommand(commandData, commandDataLen, logLevel); return result; } case (startracker::LOGSUBSCRIPTION): { - LogSubscription logSubscription; result = prepareParamCommand(commandData, commandDataLen, logSubscription); return result; } case (startracker::DEBUG_CAMERA): { - DebugCamera debugCamera; result = prepareParamCommand(commandData, commandDataLen, debugCamera); return result; } @@ -1650,6 +1637,7 @@ void StarTrackerHandler::prepareHistogramRequest() { ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData, size_t commandDataLen, ArcsecJsonParamBase& paramSet) { + Stopwatch watch; ReturnValue_t result = returnvalue::OK; if (commandDataLen > MAX_PATH_SIZE) { return FILE_PATH_TOO_LONG; diff --git a/linux/devices/startracker/StarTrackerHandler.h b/linux/devices/startracker/StarTrackerHandler.h index 3ed81047..e2b474fa 100644 --- a/linux/devices/startracker/StarTrackerHandler.h +++ b/linux/devices/startracker/StarTrackerHandler.h @@ -2,6 +2,7 @@ #define MISSION_DEVICES_STARTRACKERHANDLER_H_ #include +#include #include "ArcsecDatalinkLayer.h" #include "ArcsecJsonParamBase.h" @@ -216,6 +217,21 @@ class StarTrackerHandler : public DeviceHandlerBase { // Loading firmware requires some time and the command will not trigger a reply when executed Countdown bootCountdown; + Tracking tracking; + LogLevel logLevel; + LogSubscription logSubscription; + DebugCamera debugCamera; + Algo algo; + Validation validation; + Matching matching; + Lisa lisa; + Centroiding centroiding; + Camera camera; + ImageProcessor imageProcessor; + Mounting mounting; + Limits limits; + Subscription subscription; + #ifdef EGSE std::string paramJsonFile = "/home/pi/arcsec/json/flight-config.json"; #else From fd62efcae265396fef8fc57972114079aa483460 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 7 Mar 2023 18:47:16 +0100 Subject: [PATCH 2/7] move json init somewhere else --- bsp_q7s/core/ObjectFactory.cpp | 16 +++++++++- .../startracker/ArcsecJsonParamBase.cpp | 31 +++++++++++-------- .../devices/startracker/ArcsecJsonParamBase.h | 22 ++++++------- .../startracker/StarTrackerHandler.cpp | 22 ++++++++++++- .../devices/startracker/StarTrackerHandler.h | 12 ++----- 5 files changed, 67 insertions(+), 36 deletions(-) diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp index eaa63c72..0fb7c75c 100644 --- a/bsp_q7s/core/ObjectFactory.cpp +++ b/bsp_q7s/core/ObjectFactory.cpp @@ -908,9 +908,23 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) { startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL); starTrackerCookie->setNoFixedSizeReply(); StrHelper* strHelper = new StrHelper(objects::STR_HELPER); + + const char* paramJsonFile = nullptr; +#ifdef EGSE + paramJsonFile = "/home/pi/arcsec/json/flight-config.json"; +#else +#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1 + paramJsonFile = "/mnt/sd0/startracker/ground-config.json"; +#else + paramJsonFile = "/mnt/sd0/startracker/flight-config.json"; +#endif +#endif + if (paramJsonFile == nullptr) { + sif::error << "No valid Star Tracker parameter JSON file" << std::endl; + } auto starTracker = new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie, - strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V); + paramJsonFile, strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V); starTracker->setPowerSwitcher(pwrSwitcher); starTracker->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM); } diff --git a/linux/devices/startracker/ArcsecJsonParamBase.cpp b/linux/devices/startracker/ArcsecJsonParamBase.cpp index 05864a3f..a63025f1 100644 --- a/linux/devices/startracker/ArcsecJsonParamBase.cpp +++ b/linux/devices/startracker/ArcsecJsonParamBase.cpp @@ -5,14 +5,14 @@ ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {} ReturnValue_t ArcsecJsonParamBase::create(std::string fullname, uint8_t* buffer) { - ReturnValue_t result = returnvalue::OK; - result = init(fullname); - if (result != returnvalue::OK) { - sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set " - << setName << std::endl; - return result; - } - result = createCommand(buffer); + // ReturnValue_t result = returnvalue::OK; + // result = init(fullname); + // if (result != returnvalue::OK) { + // sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set " + // << setName << std::endl; + // return result; + // } + ReturnValue_t result = createCommand(buffer); if (result != returnvalue::OK) { sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set " << setName << std::endl; @@ -74,12 +74,17 @@ ReturnValue_t ArcsecJsonParamBase::init(const std::string filename) { << std::endl; return JSON_FILE_NOT_EXISTS; } - createJsonObject(filename); - result = initSet(); - if (result != returnvalue::OK) { - return result; + try { + createJsonObject(filename); + result = initSet(); + if (result != returnvalue::OK) { + return result; + } + return returnvalue::OK; + } catch (json::exception& e) { + // TODO: Re-create json file from backup here. + return returnvalue::FAILED; } - return returnvalue::OK; } void ArcsecJsonParamBase::createJsonObject(const std::string fullname) { diff --git a/linux/devices/startracker/ArcsecJsonParamBase.h b/linux/devices/startracker/ArcsecJsonParamBase.h index a7a4f421..49d0dbba 100644 --- a/linux/devices/startracker/ArcsecJsonParamBase.h +++ b/linux/devices/startracker/ArcsecJsonParamBase.h @@ -41,6 +41,17 @@ class ArcsecJsonParamBase { */ ArcsecJsonParamBase(std::string setName); + /** + * @brief Initializes the properties json object and the set json object + * + * @param fullname Name including absolute path to json file + * @param setName The name of the set to work on + * + * @param return JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise + * returnvalue::OK + */ + ReturnValue_t init(const std::string filename); + /** * @brief Fills a buffer with a parameter set * @@ -124,17 +135,6 @@ class ArcsecJsonParamBase { */ virtual ReturnValue_t createCommand(uint8_t* buffer) = 0; - /** - * @brief Initializes the properties json object and the set json object - * - * @param fullname Name including absolute path to json file - * @param setName The name of the set to work on - * - * @param return JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise - * returnvalue::OK - */ - ReturnValue_t init(const std::string filename); - void createJsonObject(const std::string fullname); /** diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index 77ff9156..18be03e4 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -16,7 +16,8 @@ extern "C" { } StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, - StrHelper* strHelper, power::Switch_t powerSwitch) + const char* jsonFileStr, StrHelper* strHelper, + power::Switch_t powerSwitch) : DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), @@ -41,6 +42,7 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, logSubscriptionSet(this), debugCameraSet(this), strHelper(strHelper), + paramJsonFile(jsonFileStr), powerSwitch(powerSwitch) { if (comCookie == nullptr) { sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl; @@ -60,6 +62,24 @@ ReturnValue_t StarTrackerHandler::initialize() { return result; } + // TODO: This takes ages. Move it into a separate thread, use a mutexed boolean + // to check whether init was done. Or move it into the helper class.. + // Also move update of these classes into the helper class. + tracking.init(paramJsonFile); + logLevel.init(paramJsonFile); + logSubscription.init(paramJsonFile); + debugCamera.init(paramJsonFile); + algo.init(paramJsonFile); + validation.init(paramJsonFile); + matching.init(paramJsonFile); + lisa.init(paramJsonFile); + centroiding.init(paramJsonFile); + camera.init(paramJsonFile); + imageProcessor.init(paramJsonFile); + mounting.init(paramJsonFile); + limits.init(paramJsonFile); + subscription.init(paramJsonFile); + EventManagerIF* manager = ObjectManager::instance()->get(objects::EVENT_MANAGER); if (manager == nullptr) { #if FSFW_CPP_OSTREAM_ENABLED == 1 diff --git a/linux/devices/startracker/StarTrackerHandler.h b/linux/devices/startracker/StarTrackerHandler.h index e2b474fa..09088cbb 100644 --- a/linux/devices/startracker/StarTrackerHandler.h +++ b/linux/devices/startracker/StarTrackerHandler.h @@ -36,7 +36,7 @@ class StarTrackerHandler : public DeviceHandlerBase { * to high to enable the device. */ StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, - StrHelper* strHelper, power::Switch_t powerSwitch); + const char* jsonFileStr, StrHelper* strHelper, power::Switch_t powerSwitch); virtual ~StarTrackerHandler(); ReturnValue_t initialize() override; @@ -232,15 +232,7 @@ class StarTrackerHandler : public DeviceHandlerBase { Limits limits; Subscription subscription; -#ifdef EGSE - std::string paramJsonFile = "/home/pi/arcsec/json/flight-config.json"; -#else -#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1 - std::string paramJsonFile = "/mnt/sd0/startracker/ground-config.json"; -#else - std::string paramJsonFile = "/mnt/sd0/startracker/flight-config.json"; -#endif -#endif + std::string paramJsonFile; enum class NormalState { TEMPERATURE_REQUEST, SOLUTION_REQUEST }; From 70e2a3f5f8cac6690ec210d320e8bc56459ffced Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 7 Mar 2023 19:02:19 +0100 Subject: [PATCH 3/7] bump arcsec str --- thirdparty/arcsec_star_tracker | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/thirdparty/arcsec_star_tracker b/thirdparty/arcsec_star_tracker index 93e93965..42907c36 160000 --- a/thirdparty/arcsec_star_tracker +++ b/thirdparty/arcsec_star_tracker @@ -1 +1 @@ -Subproject commit 93e93965e2c6405170b62c523dea1990db02d2ad +Subproject commit 42907c36c58e7133d3d3cbefbf96c1a8e35b60b7 From 45e1e7250b554ba61dd027c67158332785e3767d Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 7 Mar 2023 19:13:22 +0100 Subject: [PATCH 4/7] small comment --- linux/devices/startracker/StarTrackerHandler.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index 18be03e4..749607c1 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -62,7 +62,7 @@ ReturnValue_t StarTrackerHandler::initialize() { return result; } - // TODO: This takes ages. Move it into a separate thread, use a mutexed boolean + // TODO: This takes 200-250ms. Move it into a separate thread, use a mutexed boolean // to check whether init was done. Or move it into the helper class.. // Also move update of these classes into the helper class. tracking.init(paramJsonFile); From c562c4a240cf4491c88527db6d8609fd08ca8f58 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 7 Mar 2023 19:35:46 +0100 Subject: [PATCH 5/7] lets hope this fixes the occasional error --- bsp_q7s/fs/SdCardManager.cpp | 36 +++++++++++++++++++----------------- bsp_q7s/fs/SdCardManager.h | 5 ++++- 2 files changed, 23 insertions(+), 18 deletions(-) diff --git a/bsp_q7s/fs/SdCardManager.cpp b/bsp_q7s/fs/SdCardManager.cpp index 1663f7cc..d21a373e 100644 --- a/bsp_q7s/fs/SdCardManager.cpp +++ b/bsp_q7s/fs/SdCardManager.cpp @@ -21,15 +21,15 @@ SdCardManager* SdCardManager::INSTANCE = nullptr; SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) { sdLock = MutexFactory::instance()->createMutex(); - ReturnValue_t result = sdLock->lockMutex(); - if (result != returnvalue::OK) { + prefLock = MutexFactory::instance()->createMutex(); + defaultLock = MutexFactory::instance()->createMutex(); + + MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); + if (mg.getLockResult() != returnvalue::OK) { sif::error << "SdCardManager::SdCardManager: Mutex lock failed" << std::endl; } uint8_t prefSdRaw = 0; - result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw); - if (sdLock->unlockMutex() != returnvalue::OK) { - sif::error << "SdCardManager::SdCardManager: Mutex unlock failed" << std::endl; - } + ReturnValue_t result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw); if (result != returnvalue::OK) { if (result == scratch::KEY_NOT_FOUND) { @@ -37,14 +37,16 @@ SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor "Preferred SD card not set. Setting to 0" << std::endl; setPreferredSdCard(sd::SdCard::SLOT_0); - sdInfo.pref = sd::SdCard::SLOT_0; + scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast(sd::SdCard::SLOT_0)); + prefSdRaw = sd::SdCard::SLOT_0; + } else { // Should not happen. // TODO: Maybe trigger event? sif::error << "SdCardManager::SdCardManager: Reading preferred SD card from scratch" "buffer failed" << std::endl; - sdInfo.pref = sd::SdCard::SLOT_0; + prefSdRaw = sd::SdCard::SLOT_0; } } sdInfo.pref = static_cast(prefSdRaw); @@ -195,7 +197,7 @@ ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) { ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& active) { using namespace std; - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX); if (not filesystem::exists(SD_STATE_FILE)) { return STATUS_FILE_NEXISTS; } @@ -378,7 +380,7 @@ void SdCardManager::processSdStatusLine(std::pair& act } std::optional SdCardManager::getPreferredSdCard() const { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); auto res = mg.getLockResult(); if (res != returnvalue::OK) { sif::error << "SdCardManager::getPreferredSdCard: Lock error" << std::endl; @@ -387,7 +389,7 @@ std::optional SdCardManager::getPreferredSdCard() const { } ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(prefLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); if (sdCard == sd::SdCard::BOTH) { return returnvalue::FAILED; } @@ -399,7 +401,7 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() { if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) { return CommandExecutor::COMMAND_PENDING; } - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(sdLock, LOCK_TYPE, SD_LOCK_TIMEOUT, LOCK_CTX); // Use q7hw utility and pipe the command output into the state file std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE); cmdExecutor.load(updateCmd, blocking, printCmdOutput); @@ -411,7 +413,7 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() { } const char* SdCardManager::getCurrentMountPrefix() const { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); if (currentPrefix.has_value()) { return currentPrefix.value().c_str(); } @@ -464,7 +466,7 @@ void SdCardManager::setPrintCommandOutput(bool print) { this->printCmdOutput = p bool SdCardManager::isSdCardUsable(std::optional sdCard) { { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); if (markedUnusable) { return false; } @@ -560,7 +562,7 @@ ReturnValue_t SdCardManager::performFsck(sd::SdCard sdcard, bool printOutput, in } void SdCardManager::setActiveSdCard(sd::SdCard sdCard) { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); sdInfo.active = sdCard; if (sdInfo.active == sd::SdCard::SLOT_0) { currentPrefix = config::SD_0_MOUNT_POINT; @@ -570,7 +572,7 @@ void SdCardManager::setActiveSdCard(sd::SdCard sdCard) { } std::optional SdCardManager::getActiveSdCard() const { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); if (markedUnusable) { return std::nullopt; } @@ -578,6 +580,6 @@ std::optional SdCardManager::getActiveSdCard() const { } void SdCardManager::markUnusable() { - MutexGuard mg(sdLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX); + MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX); markedUnusable = true; } diff --git a/bsp_q7s/fs/SdCardManager.h b/bsp_q7s/fs/SdCardManager.h index e489e6e7..1cd09d7d 100644 --- a/bsp_q7s/fs/SdCardManager.h +++ b/bsp_q7s/fs/SdCardManager.h @@ -224,8 +224,11 @@ class SdCardManager : public SystemObject, public SdCardMountedIF { bool printCmdOutput = true; bool markedUnusable = false; MutexIF* sdLock = nullptr; + MutexIF* prefLock = nullptr; + MutexIF* defaultLock = nullptr; static constexpr MutexIF::TimeoutType LOCK_TYPE = MutexIF::TimeoutType::WAITING; - static constexpr uint32_t LOCK_TIMEOUT = 200; + static constexpr uint32_t SD_LOCK_TIMEOUT = 250; + static constexpr uint32_t OTHER_TIMEOUT = 20; static constexpr char LOCK_CTX[] = "SdCardManager"; SdCardManager(); From 01e97c8381415bafe21292ab153aa2a4cd7f4ddc Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 8 Mar 2023 01:21:18 +0100 Subject: [PATCH 6/7] OFF -> NORMAL transition works now --- fsfw | 2 +- .../startracker/StarTrackerHandler.cpp | 82 ++++++++++++------- .../devices/startracker/StarTrackerHandler.h | 46 +++++++---- 3 files changed, 83 insertions(+), 47 deletions(-) diff --git a/fsfw b/fsfw index 7f6ba5f4..1b7493f9 160000 --- a/fsfw +++ b/fsfw @@ -1 +1 @@ -Subproject commit 7f6ba5f40b47bc32802efdc4ed41b4bad4b8071b +Subproject commit 1b7493f945302b3785ceba6e7a34a727e3898a13 diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index 749607c1..ef88ea67 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -3,7 +3,9 @@ #include #include +#include #include +#include #include "OBSWConfig.h" #include "StarTrackerJsonCommands.h" @@ -15,6 +17,8 @@ extern "C" { #include "common/misc.h" } +std::atomic_bool JCFG_DONE(false); + StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, const char* jsonFileStr, StrHelper* strHelper, power::Switch_t powerSwitch) @@ -62,23 +66,10 @@ ReturnValue_t StarTrackerHandler::initialize() { return result; } - // TODO: This takes 200-250ms. Move it into a separate thread, use a mutexed boolean - // to check whether init was done. Or move it into the helper class.. - // Also move update of these classes into the helper class. - tracking.init(paramJsonFile); - logLevel.init(paramJsonFile); - logSubscription.init(paramJsonFile); - debugCamera.init(paramJsonFile); - algo.init(paramJsonFile); - validation.init(paramJsonFile); - matching.init(paramJsonFile); - lisa.init(paramJsonFile); - centroiding.init(paramJsonFile); - camera.init(paramJsonFile); - imageProcessor.init(paramJsonFile); - mounting.init(paramJsonFile); - limits.init(paramJsonFile); - subscription.init(paramJsonFile); + // Spin up a thread to do the JSON initialization, takes 200-250 ms which would + // delay whole satellite boot process. + jcfgCountdown.resetTimer(); + jsonCfgTask = std::thread{setUpJsonCfgs, std::ref(jcfgs), paramJsonFile.c_str()}; EventManagerIF* manager = ObjectManager::instance()->get(objects::EVENT_MANAGER); if (manager == nullptr) { @@ -261,8 +252,19 @@ void StarTrackerHandler::doStartUp() { // the device handler's submode to the star tracker's mode return; case StartupState::DONE: + if (jcfgCountdown.isBusy()) { + startupState = StartupState::WAIT_JCFG; + return; + } startupState = StartupState::IDLE; break; + case StartupState::WAIT_JCFG: { + if (jcfgCountdown.hasTimedOut()) { + startupState = StartupState::IDLE; + break; + } + return; + } default: return; } @@ -440,7 +442,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return returnvalue::OK; } case (startracker::SUBSCRIPTION): { - result = prepareParamCommand(commandData, commandDataLen, subscription); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.subscription); return returnvalue::OK; } case (startracker::REQ_SOLUTION): { @@ -456,55 +458,55 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return returnvalue::OK; } case (startracker::LIMITS): { - result = prepareParamCommand(commandData, commandDataLen, limits); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.limits); return result; } case (startracker::MOUNTING): { - result = prepareParamCommand(commandData, commandDataLen, mounting); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.mounting); return result; } case (startracker::IMAGE_PROCESSOR): { - result = prepareParamCommand(commandData, commandDataLen, imageProcessor); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.imageProcessor); return result; } case (startracker::CAMERA): { - result = prepareParamCommand(commandData, commandDataLen, camera); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.camera); return result; } case (startracker::CENTROIDING): { - result = prepareParamCommand(commandData, commandDataLen, centroiding); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.centroiding); return result; } case (startracker::LISA): { - result = prepareParamCommand(commandData, commandDataLen, lisa); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.lisa); return result; } case (startracker::MATCHING): { - result = prepareParamCommand(commandData, commandDataLen, matching); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.matching); return result; } case (startracker::VALIDATION): { - result = prepareParamCommand(commandData, commandDataLen, validation); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.validation); return result; } case (startracker::ALGO): { - result = prepareParamCommand(commandData, commandDataLen, algo); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.algo); return result; } case (startracker::TRACKING): { - result = prepareParamCommand(commandData, commandDataLen, tracking); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.tracking); return result; } case (startracker::LOGLEVEL): { - result = prepareParamCommand(commandData, commandDataLen, logLevel); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel); return result; } case (startracker::LOGSUBSCRIPTION): { - result = prepareParamCommand(commandData, commandDataLen, logSubscription); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription); return result; } case (startracker::DEBUG_CAMERA): { - result = prepareParamCommand(commandData, commandDataLen, debugCamera); + result = prepareParamCommand(commandData, commandDataLen, jcfgs.debugCamera); return result; } case (startracker::CHECKSUM): { @@ -753,6 +755,24 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) { } } +void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonFile) { + cfgs.tracking.init(paramJsonFile); + cfgs.logLevel.init(paramJsonFile); + cfgs.logSubscription.init(paramJsonFile); + cfgs.debugCamera.init(paramJsonFile); + cfgs.algo.init(paramJsonFile); + cfgs.validation.init(paramJsonFile); + cfgs.matching.init(paramJsonFile); + cfgs.lisa.init(paramJsonFile); + cfgs.centroiding.init(paramJsonFile); + cfgs.camera.init(paramJsonFile); + cfgs.imageProcessor.init(paramJsonFile); + cfgs.mounting.init(paramJsonFile); + cfgs.limits.init(paramJsonFile); + cfgs.subscription.init(paramJsonFile); + JCFG_DONE = true; +} + void StarTrackerHandler::bootBootloader() { if (internalState == InternalState::IDLE) { internalState = InternalState::BOOT_BOOTLOADER; diff --git a/linux/devices/startracker/StarTrackerHandler.h b/linux/devices/startracker/StarTrackerHandler.h index 09088cbb..11cf7fc3 100644 --- a/linux/devices/startracker/StarTrackerHandler.h +++ b/linux/devices/startracker/StarTrackerHandler.h @@ -4,6 +4,8 @@ #include #include +#include + #include "ArcsecDatalinkLayer.h" #include "ArcsecJsonParamBase.h" #include "OBSWConfig.h" @@ -217,20 +219,27 @@ class StarTrackerHandler : public DeviceHandlerBase { // Loading firmware requires some time and the command will not trigger a reply when executed Countdown bootCountdown; - Tracking tracking; - LogLevel logLevel; - LogSubscription logSubscription; - DebugCamera debugCamera; - Algo algo; - Validation validation; - Matching matching; - Lisa lisa; - Centroiding centroiding; - Camera camera; - ImageProcessor imageProcessor; - Mounting mounting; - Limits limits; - Subscription subscription; + struct JsonConfigs { + Tracking tracking; + LogLevel logLevel; + LogSubscription logSubscription; + DebugCamera debugCamera; + Algo algo; + Validation validation; + Matching matching; + Lisa lisa; + Centroiding centroiding; + Camera camera; + ImageProcessor imageProcessor; + Mounting mounting; + Limits limits; + Subscription subscription; + }; + JsonConfigs jcfgs; + Countdown jcfgCountdown = Countdown(250); + bool commandExecuted = false; + std::thread jsonCfgTask; + static void setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonFile); std::string paramJsonFile; @@ -270,7 +279,14 @@ class StarTrackerHandler : public DeviceHandlerBase { InternalState internalState = InternalState::IDLE; - enum class StartupState { IDLE, CHECK_PROGRAM, WAIT_CHECK_PROGRAM, BOOT_BOOTLOADER, DONE }; + enum class StartupState { + IDLE, + CHECK_PROGRAM, + WAIT_CHECK_PROGRAM, + BOOT_BOOTLOADER, + WAIT_JCFG, + DONE + }; StartupState startupState = StartupState::IDLE; From 68f4323d14fff000c94323e1ec0f6e3e6e236a17 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 8 Mar 2023 01:24:41 +0100 Subject: [PATCH 7/7] changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ff9b3511..b0e04a6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,11 @@ will consitute of a breaking change warranting a new major release: ## Fixed +- Star Tracker: OFF to NORMAL transition now posssible. Requires FSFW bump which sets + transition source modes properly for those transitions. + FSFW PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/131 +- Star Tracker JSON initialization is now done during object initization instead of redoing it + when building a command. This avoids missed deadlines issues in the ACS PST. - Allow arbitrary submodes for dual lane boards to avoid FDIR reactions of subsystem components. Bump FSFW to allow this. - PUS 15 was not scheduled