diff --git a/bsp_egse/InitMission.cpp b/bsp_egse/InitMission.cpp index 920c066d..222c8ec8 100644 --- a/bsp_egse/InitMission.cpp +++ b/bsp_egse/InitMission.cpp @@ -24,6 +24,10 @@ ServiceInterfaceStream sif::error("ERROR"); ObjectManagerIF* objectManager = nullptr; void initmission::initMission() { + sif::info << "Make sure the systemd service ser2net on the egse has been stopped " + << "(alias stop-ser2net)" << std::endl; + sif::info << "Make sure the power lines of the star tracker have been enabled " + << "(alias enable-startracker)" << std::endl; sif::info << "Building global objects.." << std::endl; /* Instantiate global object manager and also create all objects */ ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr); diff --git a/linux/devices/devicedefinitions/StarTrackerDefinitions.h b/linux/devices/devicedefinitions/StarTrackerDefinitions.h index 4e80bf42..215ef472 100644 --- a/linux/devices/devicedefinitions/StarTrackerDefinitions.h +++ b/linux/devices/devicedefinitions/StarTrackerDefinitions.h @@ -355,7 +355,7 @@ static const DeviceCommandId_t REQ_POWER = 11; static const DeviceCommandId_t TAKE_IMAGE = 15; static const DeviceCommandId_t DOWNLOAD_CENTROID = 16; static const DeviceCommandId_t UPLOAD_CENTROID = 17; -static const DeviceCommandId_t SUBSCRIBE_TO_TM = 18; +static const DeviceCommandId_t SUBSCRIPTION = 18; static const DeviceCommandId_t IMAGE_PROCESSOR = 19; static const DeviceCommandId_t REQ_SOLUTION = 24; static const DeviceCommandId_t REQ_TEMPERATURE = 25; @@ -400,6 +400,9 @@ static const DeviceCommandId_t REQ_ALGO = 77; static const DeviceCommandId_t REQ_SUBSCRIPTION = 78; static const DeviceCommandId_t REQ_LOG_SUBSCRIPTION = 79; static const DeviceCommandId_t REQ_DEBUG_CAMERA = 80; +static const DeviceCommandId_t LOGLEVEL = 81; +static const DeviceCommandId_t LOGSUBSCRIPTION = 82; +static const DeviceCommandId_t DEBUG_CAMERA = 83; static const DeviceCommandId_t NONE = 0xFFFFFFFF; static const uint32_t VERSION_SET_ID = REQ_VERSION; @@ -428,6 +431,7 @@ static const uint32_t VALIDATION_SET_ID = REQ_VALIDATION; static const uint32_t ALGO_SET_ID = REQ_ALGO; static const uint32_t SUBSCRIPTION_SET_ID = REQ_SUBSCRIPTION; static const uint32_t LOG_SUBSCRIPTION_SET_ID = REQ_LOG_SUBSCRIPTION; +static const uint32_t DEBUG_CAMERA_SET_ID = REQ_DEBUG_CAMERA; /** Max size of unencoded frame */ static const size_t MAX_FRAME_SIZE = 1200; @@ -1369,14 +1373,14 @@ class LimitsSet : public StaticLocalDataSet { /** * @brief Will store the requested log level parameters */ -class LogLevelSet : public StaticLocalDataSet { +class LogLevelSet : public StaticLocalDataSet { public: // Size of dataset static const size_t SIZE = 16; - LogLevelSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOG_LEVEL_SET_ENTRIES) {} + LogLevelSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOG_LEVEL_SET_ID) {} - LogLevelSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOG_LEVEL_SET_ENTRIES)) {} + LogLevelSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOG_LEVEL_SET_ID)) {} lp_var_t loglevel1 = lp_var_t(sid.objectId, PoolIds::LOGLEVEL1, this); lp_var_t loglevel2 = lp_var_t(sid.objectId, PoolIds::LOGLEVEL2, this); @@ -1481,14 +1485,16 @@ class ImageProcessorSet : public StaticLocalDataSet lp_var_t(sid.objectId, PoolIds::IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION, this); void printSet() { - sif::info << "ImageProcessorSet::printSet: mode: " << this->mode << std::endl; - sif::info << "ImageProcessorSet::printSet: store: " << this->store << std::endl; + sif::info << "ImageProcessorSet::printSet: mode: " + << static_cast(this->mode.value) << std::endl; + sif::info << "ImageProcessorSet::printSet: store: " + << static_cast(this->store.value) << std::endl; sif::info << "ImageProcessorSet::printSet: signal threshold: " << this->signalThreshold << std::endl; sif::info << "ImageProcessorSet::printSet: dark threshold: " << this->darkThreshold << std::endl; sif::info << "ImageProcessorSet::printSet: background compensation: " - << this->backgroundCompensation << std::endl; + << static_cast(this->backgroundCompensation.value) << std::endl; } }; @@ -1532,7 +1538,8 @@ class CentroidingSet : public StaticLocalDataSet lp_var_t(sid.objectId, PoolIds::CENTROIDING_TRANSMATRIX11, this); void printSet() { - sif::info << "CentroidingSet::printSet: enable filter: " << this->enableFilter << std::endl; + sif::info << "CentroidingSet::printSet: enable filter: " + << static_cast(this->enableFilter.value) << std::endl; sif::info << "CentroidingSet::printSet: max quality: " << this->maxQuality << std::endl; sif::info << "CentroidingSet::printSet: dark threshold: " << this->darkThreshold << std::endl; sif::info << "CentroidingSet::printSet: min quality: " << this->minQuality << std::endl; @@ -1604,8 +1611,10 @@ class LisaSet : public StaticLocalDataSet { << std::endl; sif::info << "LisaSet::printSet: rating weight db star count: " << this->ratingWeightDbStarCount << std::endl; - sif::info << "LisaSet::printSet: max combinations: " << this->maxCombinations << std::endl; - sif::info << "LisaSet::printSet: nr stars stop: " << this->nrStarsStop << std::endl; + sif::info << "LisaSet::printSet: max combinations: " + << static_cast(this->maxCombinations.value) << std::endl; + sif::info << "LisaSet::printSet: nr stars stop: " + << static_cast(this->nrStarsStop.value) << std::endl; sif::info << "LisaSet::printSet: fraction close stop: " << this->fractionCloseStop << std::endl; } }; @@ -1639,7 +1648,7 @@ class MatchingSet : public StaticLocalDataSet { class TrackingSet : public StaticLocalDataSet { public: // Size of dataset - static const size_t SIZE = 16; + static const size_t SIZE = 13; TrackingSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TRACKING_SET_ID) {} @@ -1648,13 +1657,16 @@ class TrackingSet : public StaticLocalDataSet { lp_var_t thinLimit = lp_var_t(sid.objectId, PoolIds::TRACKING_THIN_LIMIT, this); lp_var_t outlierThreshold = lp_var_t(sid.objectId, PoolIds::TRACKING_OUTLIER_THRESHOLD, this); lp_var_t outlierThresholdQuest = lp_var_t(sid.objectId, PoolIds::TRACKING_OUTLIER_THRESHOLD_QUEST, this); - lp_var_t trackerChoice = lp_var_t(sid.objectId, PoolIds::TRACKING_TRACKER_CHOICE, this); + lp_var_t trackerChoice = lp_var_t(sid.objectId, PoolIds::TRACKING_TRACKER_CHOICE, this); void printSet() { - sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredDistanceLimit + sif::info << "TrackingSet::printSet: thin limit: " << this->thinLimit << std::endl; + sif::info << "TrackingSet::printSet: outlier threshold: " << this->outlierThreshold << std::endl; - sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredShiftLimit + sif::info << "TrackingSet::printSet: outlier threshold quest: " << this->outlierThresholdQuest << std::endl; + sif::info << "TrackingSet::printSet: tracker choice: " + << static_cast(this->trackerChoice.value) << std::endl; } }; @@ -1681,12 +1693,12 @@ class ValidationSet : public StaticLocalDataSet { void printSet() { sif::info << "ValidationSet::printSet: stable count: " - << static_cast(this->stableCount) << std::endl; + << static_cast(this->stableCount.value) << std::endl; sif::info << "ValidationSet::printSet: max difference: " << this->maxDifference << std::endl; sif::info << "ValidationSet::printSet: min tracker confidence: " << this->minTrackerConfidence << std::endl; - sif::info << "ValidationSet::printSet: min matched stars: " << this->minMatchedStars - << std::endl; + sif::info << "ValidationSet::printSet: min matched stars: " + << static_cast(this->minMatchedStars.value) << std::endl; } }; @@ -1714,13 +1726,13 @@ class AlgoSet : public StaticLocalDataSet { lp_var_t(sid.objectId, PoolIds::ALGO_I2L_MIN_MATCHED, this); void printSet() { - sif::info << "AlgoSet::printSet: mode: " << static_cast(this->mode) << std::endl; + sif::info << "AlgoSet::printSet: mode: " << static_cast(this->mode.value) << std::endl; sif::info << "AlgoSet::printSet: i2t min confidence: " << this->i2tMinConfidence << std::endl; sif::info << "AlgoSet::printSet: i2t min matched: " - << static_cast(this->i2tMinMatched) << std::endl; + << static_cast(this->i2tMinMatched.value) << std::endl; sif::info << "AlgoSet::printSet: i2l min confidence: " << this->i2lMinConfidence << std::endl; sif::info << "AlgoSet::printSet: i2l min matched: " - << static_cast(this->i2lMinMatched) << std::endl; + << static_cast(this->i2lMinMatched.value) << std::endl; } }; @@ -1755,38 +1767,38 @@ class SubscriptionSet : public StaticLocalDataSet { lp_var_t tm16 = lp_var_t(sid.objectId, PoolIds::SUBSCRIPTION_TM16, this); void printSet() { - sif::info << "SubscriptionSet::printSet: telemetry 1: " << static_cast(this->tm1) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 2: " << static_cast(this->tm2) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 3: " << static_cast(this->tm3) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 4: " << static_cast(this->tm4) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 5: " << static_cast(this->tm5) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 6: " << static_cast(this->tm6) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 7: " << static_cast(this->tm7) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 8: " << static_cast(this->tm8) - << std::endl; - sif::info << "SubscriptionSet::printSet: telemetry 9: " << static_cast(this->tm9) - << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 1: " + << static_cast(this->tm1.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 2: " + << static_cast(this->tm2.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 3: " + << static_cast(this->tm3.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 4: " + << static_cast(this->tm4.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 5: " + << static_cast(this->tm5.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 6: " + << static_cast(this->tm6.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 7: " + << static_cast(this->tm7.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 8: " + << static_cast(this->tm8.value) << std::endl; + sif::info << "SubscriptionSet::printSet: telemetry 9: " + << static_cast(this->tm9.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 10: " - << static_cast(this->tm10) << std::endl; + << static_cast(this->tm10.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 11: " - << static_cast(this->tm11) << std::endl; + << static_cast(this->tm11.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 12: " - << static_cast(this->tm12) << std::endl; + << static_cast(this->tm12.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 13: " - << static_cast(this->tm13) << std::endl; + << static_cast(this->tm13.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 14: " - << static_cast(this->tm14) << std::endl; + << static_cast(this->tm14.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 15: " - << static_cast(this->tm15) << std::endl; + << static_cast(this->tm15.value) << std::endl; sif::info << "SubscriptionSet::printSet: telemetry 16: " - << static_cast(this->tm16) << std::endl; + << static_cast(this->tm16.value) << std::endl; } }; @@ -1815,13 +1827,13 @@ class LogSubscriptionSet : public StaticLocalDataSet(this->level1) << std::endl; + << static_cast(this->level1.value) << std::endl; sif::info << "LogSubscriptionSet::printSet: module 1: " - << static_cast(this->module1) << std::endl; + << static_cast(this->module1.value) << std::endl; sif::info << "LogSubscriptionSet::printSet: level 2: " - << static_cast(this->level2) << std::endl; + << static_cast(this->level2.value) << std::endl; sif::info << "LogSubscriptionSet::printSet: module 2: " - << static_cast(this->module2) << std::endl; + << static_cast(this->module2.value) << std::endl; } }; @@ -1845,8 +1857,8 @@ class DebugCameraSet : public StaticLocalDataSet { : StaticLocalDataSet(sid_t(objectId, DEBUG_CAMERA_SET_ID)) {} void printSet() { - sif::info << "DebugCameraSet::printSet: level 1: " << this->timing << std::endl; - sif::info << "DebugCameraSet::printSet: module 1: " << this->test << std::endl; + sif::info << "DebugCameraSet::printSet: timing: " << this->timing << std::endl; + sif::info << "DebugCameraSet::printSet: test: " << this->test << std::endl; } }; } // namespace StarTracker diff --git a/linux/devices/startracker/ArcsecJsonKeys.h b/linux/devices/startracker/ArcsecJsonKeys.h index 28d4ad3f..34989b1f 100644 --- a/linux/devices/startracker/ArcsecJsonKeys.h +++ b/linux/devices/startracker/ArcsecJsonKeys.h @@ -126,9 +126,56 @@ static const char TRACKER_CHOICE[] = "trackerChoice"; static const char ALGO[] = "algo"; static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence"; -static const char L2T_MIN_MATCHED[] = "l2t_minConfidence"; +static const char L2T_MIN_MATCHED[] = "l2t_minMatched"; static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence"; static const char T2L_MIN_MATCHED[] = "t2l_minMatched"; + +static const char LOGLEVEL[] = "loglevel"; +static const char LOGLEVEL1[] = "loglevel1"; +static const char LOGLEVEL2[] = "loglevel2"; +static const char LOGLEVEL3[] = "loglevel3"; +static const char LOGLEVEL4[] = "loglevel4"; +static const char LOGLEVEL5[] = "loglevel5"; +static const char LOGLEVEL6[] = "loglevel6"; +static const char LOGLEVEL7[] = "loglevel7"; +static const char LOGLEVEL8[] = "loglevel8"; +static const char LOGLEVEL9[] = "loglevel9"; +static const char LOGLEVEL10[] = "loglevel10"; +static const char LOGLEVEL11[] = "loglevel11"; +static const char LOGLEVEL12[] = "loglevel12"; +static const char LOGLEVEL13[] = "loglevel13"; +static const char LOGLEVEL14[] = "loglevel14"; +static const char LOGLEVEL15[] = "loglevel15"; +static const char LOGLEVEL16[] = "loglevel16"; + +static const char SUBSCRIPTION[] = "subscription"; +static const char TELEMETRY_1[] = "telemetry1"; +static const char TELEMETRY_2[] = "telemetry2"; +static const char TELEMETRY_3[] = "telemetry3"; +static const char TELEMETRY_4[] = "telemetry4"; +static const char TELEMETRY_5[] = "telemetry5"; +static const char TELEMETRY_6[] = "telemetry6"; +static const char TELEMETRY_7[] = "telemetry7"; +static const char TELEMETRY_8[] = "telemetry8"; +static const char TELEMETRY_9[] = "telemetry9"; +static const char TELEMETRY_10[] = "telemetry10"; +static const char TELEMETRY_11[] = "telemetry11"; +static const char TELEMETRY_12[] = "telemetry12"; +static const char TELEMETRY_13[] = "telemetry13"; +static const char TELEMETRY_14[] = "telemetry14"; +static const char TELEMETRY_15[] = "telemetry15"; +static const char TELEMETRY_16[] = "telemetry16"; + +static const char LOG_SUBSCRIPTION[] = "logsubscription"; +static const char LEVEL1[] = "level1"; +static const char MODULE1[] = "module1"; +static const char LEVEL2[] = "level2"; +static const char MODULE2[] = "module2"; + +static const char DEBUG_CAMERA[] = "debugcamera"; +static const char TIMING[] = "timing"; +static const char TEST[] = "test"; + } // namespace arcseckeys #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */ diff --git a/linux/devices/startracker/StarTrackerHandler.cpp b/linux/devices/startracker/StarTrackerHandler.cpp index a24284bf..9324458c 100644 --- a/linux/devices/startracker/StarTrackerHandler.cpp +++ b/linux/devices/startracker/StarTrackerHandler.cpp @@ -270,6 +270,7 @@ void StarTrackerHandler::doStartUp() { } return; case StartupState::DONE: + startupState = StartupState::IDLE; break; default: return; @@ -405,8 +406,9 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi prepareTakeImageCommand(commandData); return RETURN_OK; } - case (StarTracker::SUBSCRIBE_TO_TM): { - prepareSubscriptionCommand(commandData); + case (StarTracker::SUBSCRIPTION): { + Subscription subscription; + result = prepareParamCommand(commandData, commandDataLen, subscription); return RETURN_OK; } case (StarTracker::REQ_SOLUTION): { @@ -479,6 +481,21 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi 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; + } case (StarTracker::ERASE): { result = prepareEraseCommand(commandData, commandDataLen); return result; @@ -536,7 +553,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return result; } case (StarTracker::REQ_IMAGE_PROCESSOR): { - result = prepareRequestMountignParams(); + result = prepareRequestImageProcessorParams(); return result; } case (StarTracker::REQ_CENTROIDING): { @@ -548,7 +565,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi return result; } case (StarTracker::REQ_MATCHING): { - result = prepareRequetMatchingParams(); + result = prepareRequestMatchingParams(); return result; } case (StarTracker::REQ_TRACKING): { @@ -571,6 +588,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareRequestLogSubscriptionParams(); return result; } + case (StarTracker::REQ_DEBUG_CAMERA): { + result = prepareRequestDebugCameraParams(); + return result; + } default: return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; } @@ -595,7 +616,7 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); // Reboot has no reply. Star tracker reboots immediately this->insertInCommandMap(StarTracker::SWITCH_TO_BOOTLOADER_PROGRAM); - this->insertInCommandAndReplyMap(StarTracker::SUBSCRIBE_TO_TM, 3, nullptr, + this->insertInCommandAndReplyMap(StarTracker::SUBSCRIPTION, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::REQ_SOLUTION, 3, &solutionSet, StarTracker::MAX_FRAME_SIZE * 2 + 2); @@ -605,6 +626,12 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::REQ_CONTRAST, 3, &contrastSet, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::LOGLEVEL, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::LOGSUBSCRIPTION, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::DEBUG_CAMERA, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::LIMITS, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::MOUNTING, 3, nullptr, @@ -739,10 +766,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, ReturnValue_t result = RETURN_OK; switch (id) { - case (StarTracker::SUBSCRIBE_TO_TM): { - result = handleSetParamReply(); - break; - } case (StarTracker::REQ_TIME): { result = handleTm(timeSet, StarTracker::TimeSet::SIZE); break; @@ -823,6 +846,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, result = handleTm(contrastSet, StarTracker::ContrastSet::SIZE); break; } + case (StarTracker::SUBSCRIPTION): + case (StarTracker::LOGLEVEL): + case (StarTracker::LOGSUBSCRIPTION): + case (StarTracker::DEBUG_CAMERA): case (StarTracker::LIMITS): case (StarTracker::MOUNTING): case (StarTracker::CAMERA): @@ -844,13 +871,60 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE); break; } + case (StarTracker::REQ_LOG_LEVEL): { + handleParamRequest(loglevelSet, StarTracker::LogLevelSet::SIZE); + break; + } + case (StarTracker::REQ_MOUNTING): { + handleParamRequest(mountingSet, StarTracker::MountingSet::SIZE); + break; + } + case (StarTracker::REQ_IMAGE_PROCESSOR): { + handleParamRequest(imageProcessorSet, StarTracker::ImageProcessorSet::SIZE); + break; + } + case (StarTracker::REQ_CENTROIDING): { + handleParamRequest(centroidingSet, StarTracker::CentroidingSet::SIZE); + break; + } + case (StarTracker::REQ_LISA): { + handleParamRequest(lisaSet, StarTracker::LisaSet::SIZE); + break; + } + case (StarTracker::REQ_MATCHING): { + handleParamRequest(matchingSet, StarTracker::MatchingSet::SIZE); + break; + } + case (StarTracker::REQ_TRACKING): { + handleParamRequest(trackingSet, StarTracker::TrackingSet::SIZE); + break; + } + case (StarTracker::REQ_VALIDATION): { + handleParamRequest(validationSet, StarTracker::ValidationSet::SIZE); + break; + } + case (StarTracker::REQ_ALGO): { + handleParamRequest(algoSet, StarTracker::AlgoSet::SIZE); + break; + } + case (StarTracker::REQ_SUBSCRIPTION): { + handleParamRequest(subscriptionSet, StarTracker::SubscriptionSet::SIZE); + break; + } + case (StarTracker::REQ_LOG_SUBSCRIPTION): { + handleParamRequest(logSubscriptionSet, StarTracker::LogSubscriptionSet::SIZE); + break; + } + case (StarTracker::REQ_DEBUG_CAMERA): { + handleParamRequest(debugCameraSet, StarTracker::DebugCameraSet::SIZE); + break; + } default: { sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id << std::endl; result = DeviceHandlerIF::UNKNOWN_DEVICE_REPLY; } } - return result; } @@ -1147,7 +1221,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l localDataPoolMap.emplace(StarTracker::TRACKING_THIN_LIMIT, new PoolEntry({0})); localDataPoolMap.emplace(StarTracker::TRACKING_OUTLIER_THRESHOLD, new PoolEntry({0})); localDataPoolMap.emplace(StarTracker::TRACKING_OUTLIER_THRESHOLD_QUEST, new PoolEntry({0})); - localDataPoolMap.emplace(StarTracker::TRACKING_TRACKER_CHOICE, new PoolEntry({0})); + localDataPoolMap.emplace(StarTracker::TRACKING_TRACKER_CHOICE, new PoolEntry({0})); localDataPoolMap.emplace(StarTracker::VALIDATION_STABLE_COUNT, new PoolEntry({0})); localDataPoolMap.emplace(StarTracker::VALIDATION_MAX_DIFFERENCE, new PoolEntry({0})); @@ -1182,8 +1256,8 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l localDataPoolMap.emplace(StarTracker::LOG_SUBSCRIPTION_LEVEL2, new PoolEntry({0})); localDataPoolMap.emplace(StarTracker::LOG_SUBSCRIPTION_MODULE2, new PoolEntry({0})); - localDataPoolMap.emplace(StarTracker::DEBUG_CAMERA_TIMING, new PoolEntry({0})); - localDataPoolMap.emplace(StarTracker::DEBUG_CAMERA_TEST, new PoolEntry({0})); + localDataPoolMap.emplace(StarTracker::DEBUG_CAMERA_TIMING, new PoolEntry({0})); + localDataPoolMap.emplace(StarTracker::DEBUG_CAMERA_TEST, new PoolEntry({0})); return RETURN_OK; } @@ -1280,7 +1354,7 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId) break; } default: - sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" + sif::warning << "StarTrackerHandler::scanForActionReply: Unknown parameter reply id" << std::endl; return RETURN_FAILED; } @@ -1291,7 +1365,7 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* fo const uint8_t* reply = dataLinkLayer.getReply(); switch (*reply) { case (StarTracker::ID::SUBSCRIPTION): { - *foundId = StarTracker::SUBSCRIBE_TO_TM; + *foundId = StarTracker::SUBSCRIPTION; break; } case (StarTracker::ID::LIMITS): { @@ -1334,6 +1408,18 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* fo *foundId = StarTracker::ALGO; break; } + case (StarTracker::ID::LOG_LEVEL): { + *foundId = StarTracker::LOGLEVEL; + break; + } + case (StarTracker::ID::DEBUG_CAMERA): { + *foundId = StarTracker::DEBUG_CAMERA; + break; + } + case (StarTracker::ID::LOG_SUBSCRIPTION): { + *foundId = StarTracker::LOGSUBSCRIPTION; + break; + } default: sif::debug << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" << std::endl; @@ -1390,7 +1476,7 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* fo break; } case (StarTracker::ID::SUBSCRIPTION): { - *foundId = StarTracker::SUBSCRIPTION; + *foundId = StarTracker::REQ_SUBSCRIPTION; break; } case (StarTracker::ID::LOG_SUBSCRIPTION): { @@ -1862,32 +1948,6 @@ void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) { rawPacketLen = dataLinkLayer.getEncodedLength(); } -void StarTrackerHandler::prepareSubscriptionCommand(const uint8_t* tmId) { - uint32_t length = 18; - commandBuffer[0] = TMTC_SETPARAMREQ; - commandBuffer[1] = StarTracker::ID::SUBSCRIPTION; - // Fill all other fields with invalid tm id - commandBuffer[2] = *tmId; - commandBuffer[3] = 0; - commandBuffer[4] = 0; - commandBuffer[5] = 0; - commandBuffer[6] = 0; - commandBuffer[7] = 0; - commandBuffer[8] = 0; - commandBuffer[9] = 0; - commandBuffer[10] = 0; - commandBuffer[11] = 0; - commandBuffer[12] = 0; - commandBuffer[13] = 0; - commandBuffer[14] = 0; - commandBuffer[15] = 0; - commandBuffer[16] = 0; - commandBuffer[17] = 0; - dataLinkLayer.encodeFrame(commandBuffer, length); - rawPacket = dataLinkLayer.getEncodedFrame(); - rawPacketLen = dataLinkLayer.getEncodedLength(); -} - void StarTrackerHandler::prepareSolutionRequest() { uint32_t length = 0; arc_tm_pack_solution_req(commandBuffer, &length); @@ -2033,7 +2093,7 @@ ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() { return RETURN_OK; } -ReturnValue_t StarTrackerHandler::prepareRequestPropertyParams() { +ReturnValue_t StarTrackerHandler::prepareRequestLogLevelParams() { uint32_t length = 0; arc_pack_loglevel_parameter_req(commandBuffer, &length); dataLinkLayer.encodeFrame(commandBuffer, length); @@ -2042,6 +2102,105 @@ ReturnValue_t StarTrackerHandler::prepareRequestPropertyParams() { return RETURN_OK; } +ReturnValue_t StarTrackerHandler::prepareRequestMountingParams() { + uint32_t length = 0; + arc_pack_mounting_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestImageProcessorParams() { + uint32_t length = 0; + arc_pack_imageprocessor_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestCentroidingParams() { + uint32_t length = 0; + arc_pack_centroiding_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestLisaParams() { + uint32_t length = 0; + arc_pack_lisa_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestMatchingParams() { + uint32_t length = 0; + arc_pack_matching_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestTrackingParams() { + uint32_t length = 0; + arc_pack_tracking_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestValidationParams() { + uint32_t length = 0; + arc_pack_validation_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestAlgoParams() { + uint32_t length = 0; + arc_pack_algo_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestSubscriptionParams() { + uint32_t length = 0; + arc_pack_subscription_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestLogSubscriptionParams() { + uint32_t length = 0; + arc_pack_logsubscription_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareRequestDebugCameraParams() { + uint32_t length = 0; + arc_pack_debugcamera_parameter_req(commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + ReturnValue_t StarTrackerHandler::handleSetParamReply() { const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = *(reply + STATUS_OFFSET); diff --git a/linux/devices/startracker/StarTrackerJsonCommands.cpp b/linux/devices/startracker/StarTrackerJsonCommands.cpp index c9d09a96..d8ddb7ca 100644 --- a/linux/devices/startracker/StarTrackerJsonCommands.cpp +++ b/linux/devices/startracker/StarTrackerJsonCommands.cpp @@ -504,6 +504,12 @@ ReturnValue_t Lisa::createCommand(uint8_t* buffer) { } addfloat(param, buffer + offset); offset += sizeof(float); + result = getParam(arcseckeys::RATING_WEIGHT_MEAN_SUM, param); + if (result != RETURN_OK) { + return result; + } + addfloat(param, buffer + offset); + offset += sizeof(float); result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param); if (result != RETURN_OK) { return result; @@ -632,3 +638,280 @@ ReturnValue_t Algo::createCommand(uint8_t* buffer) { adduint8(param, buffer + offset); return RETURN_OK; } + +LogLevel::LogLevel() : ArcsecJsonParamBase(arcseckeys::LOGLEVEL) {} + +size_t LogLevel::getSize() { return COMMAND_SIZE; } + +ReturnValue_t LogLevel::createCommand(uint8_t* buffer) { + ReturnValue_t result = RETURN_OK; + uint8_t offset = 0; + std::string param; + addSetParamHeader(buffer, StarTracker::ID::LOG_LEVEL); + offset = 2; + result = getParam(arcseckeys::LOGLEVEL1, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL2, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL3, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL4, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL5, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL6, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL7, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL8, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL9, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL10, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL11, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL12, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL13, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL14, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL15, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LOGLEVEL16, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + + return RETURN_OK; +} + +Subscription::Subscription() : ArcsecJsonParamBase(arcseckeys::SUBSCRIPTION) {} + +size_t Subscription::getSize() { return COMMAND_SIZE; } + +ReturnValue_t Subscription::createCommand(uint8_t* buffer) { + ReturnValue_t result = RETURN_OK; + uint8_t offset = 0; + std::string param; + addSetParamHeader(buffer, StarTracker::ID::SUBSCRIPTION); + offset = 2; + result = getParam(arcseckeys::TELEMETRY_1, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_2, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_3, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_4, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_5, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_6, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_7, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_8, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_9, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_10, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_11, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_12, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_13, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_14, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_15, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::TELEMETRY_16, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + return RETURN_OK; +} + +LogSubscription::LogSubscription() : ArcsecJsonParamBase(arcseckeys::LOG_SUBSCRIPTION) {} + +size_t LogSubscription::getSize() { return COMMAND_SIZE; } + +ReturnValue_t LogSubscription::createCommand(uint8_t* buffer) { + ReturnValue_t result = RETURN_OK; + uint8_t offset = 0; + std::string param; + addSetParamHeader(buffer, StarTracker::ID::LOG_SUBSCRIPTION); + offset = 2; + result = getParam(arcseckeys::LEVEL1, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::MODULE1, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::LEVEL2, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + offset += sizeof(uint8_t); + result = getParam(arcseckeys::MODULE2, param); + if (result != RETURN_OK) { + return result; + } + adduint8(param, buffer + offset); + return RETURN_OK; +} + +DebugCamera::DebugCamera() : ArcsecJsonParamBase(arcseckeys::DEBUG_CAMERA) {} + +size_t DebugCamera::getSize() { return COMMAND_SIZE; } + +ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) { + ReturnValue_t result = RETURN_OK; + uint8_t offset = 0; + std::string param; + addSetParamHeader(buffer, StarTracker::ID::DEBUG_CAMERA); + offset = 2; + result = getParam(arcseckeys::TIMING, param); + if (result != RETURN_OK) { + return result; + } + adduint32(param, buffer + offset); + offset += sizeof(uint32_t); + result = getParam(arcseckeys::TEST, param); + if (result != RETURN_OK) { + return result; + } + adduint32(param, buffer + offset); + return RETURN_OK; +} diff --git a/linux/devices/startracker/StarTrackerJsonCommands.h b/linux/devices/startracker/StarTrackerJsonCommands.h index 2c816056..a827d829 100644 --- a/linux/devices/startracker/StarTrackerJsonCommands.h +++ b/linux/devices/startracker/StarTrackerJsonCommands.h @@ -173,4 +173,68 @@ class Algo : public ArcsecJsonParamBase { ReturnValue_t createCommand(uint8_t* buffer) override; }; +/** + * @brief Generates command to configure the log level parameters. + * + */ +class LogLevel : public ArcsecJsonParamBase { + public: + LogLevel(); + + size_t getSize(); + + private: + static const size_t COMMAND_SIZE = 18; + + ReturnValue_t createCommand(uint8_t* buffer) override; +}; + +/** + * @brief Generates command to set subscription parameters. + * + */ +class Subscription : public ArcsecJsonParamBase { + public: + Subscription(); + + size_t getSize(); + + private: + static const size_t COMMAND_SIZE = 18; + + ReturnValue_t createCommand(uint8_t* buffer) override; +}; + +/** + * @brief Generates command to set log subscription parameters. + * + */ +class LogSubscription : public ArcsecJsonParamBase { + public: + LogSubscription(); + + size_t getSize(); + + private: + static const size_t COMMAND_SIZE = 6; + + ReturnValue_t createCommand(uint8_t* buffer) override; +}; + +/** + * @brief Generates command to set debug camera parameters + * + */ +class DebugCamera : public ArcsecJsonParamBase { + public: + DebugCamera(); + + size_t getSize(); + + private: + static const size_t COMMAND_SIZE = 10; + + ReturnValue_t createCommand(uint8_t* buffer) override; +}; + #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_ */