eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 Wiki Activity

commands to disable and enable star tracker filename timestamping
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller 2022-02-24 13:47:52 +01:00
parent b822ee77bc
commit 2419e9fcc6
6 changed files with 2289 additions and 2249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fsfw

@ -1 +1 @@
Subproject commit c20bf31d5d9f7ed18d15f2a3211a14f28242eeb6 Subproject commit 3c06d2dbbb0d79608e003a8a3c89ae90cc71f409

2
linux/devices/devicedefinitions/StarTrackerDefinitions.h
View File

@ -399,6 +399,8 @@ static const DeviceCommandId_t LOGLEVEL = 81;
static const DeviceCommandId_t LOGSUBSCRIPTION = 82; static const DeviceCommandId_t LOGSUBSCRIPTION = 82;
static const DeviceCommandId_t DEBUG_CAMERA = 83; static const DeviceCommandId_t DEBUG_CAMERA = 83;
static const DeviceCommandId_t FIRMWARE_UPDATE = 84; static const DeviceCommandId_t FIRMWARE_UPDATE = 84;
static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
static const DeviceCommandId_t NONE = 0xFFFFFFFF; static const DeviceCommandId_t NONE = 0xFFFFFFFF;
static const uint32_t VERSION_SET_ID = REQ_VERSION; static const uint32_t VERSION_SET_ID = REQ_VERSION;

166
linux/devices/startracker/StarTrackerHandler.cpp
View File

@ -19,36 +19,14 @@ extern "C" {
using json = nlohmann::json; using json = nlohmann::json;
StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
StrHelper* strHelper) StrHelper* strHelper) :
: DeviceHandlerBase(objectId, comIF, comCookie), DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet(
temperatureSet(this), this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), contrastSet(
versionSet(this), this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this), downloadDbImage(
powerSet(this), this), downloadBlobPixel(this), cameraSet(this), limitsSet(this), loglevelSet(this), mountingSet(
interfaceSet(this), this), imageProcessorSet(this), centroidingSet(this), lisaSet(this), matchingSet(
timeSet(this), this), trackingSet(this), validationSet(this), algoSet(this), subscriptionSet(this), logSubscriptionSet(
solutionSet(this), this), debugCameraSet(this), strHelper(strHelper) {
histogramSet(this),
contrastSet(this),
checksumSet(this),
downloadCentroidSet(this),
downloadMatchedStar(this),
downloadDbImage(this),
downloadBlobPixel(this),
cameraSet(this),
limitsSet(this),
loglevelSet(this),
mountingSet(this),
imageProcessorSet(this),
centroidingSet(this),
lisaSet(this),
matchingSet(this),
trackingSet(this),
validationSet(this),
algoSet(this),
subscriptionSet(this),
logSubscriptionSet(this),
debugCameraSet(this),
strHelper(strHelper) {
if (comCookie == nullptr) { if (comCookie == nullptr) {
sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl; sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
} }
@ -58,7 +36,8 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5); eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
} }
StarTrackerHandler::~StarTrackerHandler() {} StarTrackerHandler::~StarTrackerHandler() {
}
ReturnValue_t StarTrackerHandler::initialize() { ReturnValue_t StarTrackerHandler::initialize() {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
@ -67,13 +46,13 @@ ReturnValue_t StarTrackerHandler::initialize() {
return result; return result;
} }
EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER); EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(
objects::EVENT_MANAGER);
if (manager == nullptr) { if (manager == nullptr) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "StarTrackerHandler::initialize: Invalid event manager" << std::endl; sif::error << "StarTrackerHandler::initialize: Invalid event manager" << std::endl;
#endif #endif
return ObjectManagerIF::CHILD_INIT_FAILED; return ObjectManagerIF::CHILD_INIT_FAILED;;
;
} }
result = manager->registerListener(eventQueue->getId()); result = manager->registerListener(eventQueue->getId());
if (result != RETURN_OK) { if (result != RETURN_OK) {
@ -115,6 +94,12 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
paramJsonFile = std::string(reinterpret_cast<const char*>(data), size); paramJsonFile = std::string(reinterpret_cast<const char*>(data), size);
return EXECUTION_FINISHED; return EXECUTION_FINISHED;
} }
case (startracker::DISABLE_TIMESTAMP_GENERATION):
strHelper->disableTimestamping();
break;
case (startracker::ENABLE_TIMESTAMP_GENERATION):
strHelper->enableTimestamping();
break;
default: default:
break; break;
} }
@ -143,7 +128,8 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (size > MAX_PATH_SIZE + MAX_FILE_NAME) { if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
} }
result = strHelper->startImageUpload(std::string(reinterpret_cast<const char*>(data), size)); result = strHelper->startImageUpload(
std::string(reinterpret_cast<const char*>(data), size));
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -158,8 +144,8 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (size > MAX_PATH_SIZE) { if (size > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
} }
result = result = strHelper->startImageDownload(
strHelper->startImageDownload(std::string(reinterpret_cast<const char*>(data), size)); std::string(reinterpret_cast<const char*>(data), size));
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -200,8 +186,8 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (size > MAX_PATH_SIZE + MAX_FILE_NAME) { if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
} }
result = result = strHelper->startFirmwareUpdate(
strHelper->startFirmwareUpdate(std::string(reinterpret_cast<const char*>(data), size)); std::string(reinterpret_cast<const char*>(data), size));
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -216,8 +202,8 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
void StarTrackerHandler::performOperationHook() { void StarTrackerHandler::performOperationHook() {
EventMessage event; EventMessage event;
for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK; for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK; result =
result = eventQueue->receiveMessage(&event)) { eventQueue->receiveMessage(&event)) {
switch (event.getMessageId()) { switch (event.getMessageId()) {
case EventMessage::EVENT_MESSAGE: case EventMessage::EVENT_MESSAGE:
handleEvent(&event); handleEvent(&event);
@ -255,7 +241,9 @@ void StarTrackerHandler::doShutDown() {
setMode(_MODE_POWER_DOWN); setMode(_MODE_POWER_DOWN);
} }
void StarTrackerHandler::doOffActivity() { internalState = InternalState::IDLE; } void StarTrackerHandler::doOffActivity() {
internalState = InternalState::IDLE;
}
ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
switch (normalState) { switch (normalState) {
@ -375,8 +363,7 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
} }
ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t* commandData, const uint8_t* commandData, size_t commandDataLen) {
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
switch (deviceCommand) { switch (deviceCommand) {
case (startracker::PING_REQUEST): { case (startracker::PING_REQUEST): {
@ -882,6 +869,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
case (startracker::RESET_ERROR): case (startracker::RESET_ERROR):
case (startracker::UNLOCK): case (startracker::UNLOCK):
case (startracker::SET_TIME): case (startracker::SET_TIME):
break;
case (startracker::DOWNLOAD_CENTROID): { case (startracker::DOWNLOAD_CENTROID): {
result = handleActionReplySet(downloadCentroidSet, startracker::DownloadCentroidSet::SIZE); result = handleActionReplySet(downloadCentroidSet, startracker::DownloadCentroidSet::SIZE);
break; break;
@ -1027,7 +1015,8 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
return result; return result;
} }
void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {} void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {
}
uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
// if (modeTo == MODE_ON && (submode == SUBMODE_NONE || submode == SUBMODE_BOOTLOADER)) { // if (modeTo == MODE_ON && (submode == SUBMODE_NONE || submode == SUBMODE_BOOTLOADER)) {
@ -1225,7 +1214,8 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(startracker::BLOBPIX_Y, new PoolEntry<uint32_t>( { 0 })); localDataPoolMap.emplace(startracker::BLOBPIX_Y, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(startracker::BLOBPIX_TOT_VAL, new PoolEntry<uint32_t>( { 0 })); localDataPoolMap.emplace(startracker::BLOBPIX_TOT_VAL, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(startracker::BLOBPIX_IN_USE, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::BLOBPIX_IN_USE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::BLOBPIX_BRIGHT_NEIGHBOURS, new PoolEntry<uint32_t>({0})); localDataPoolMap.emplace(startracker::BLOBPIX_BRIGHT_NEIGHBOURS,
new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(startracker::BLOBPIX_REGION, new PoolEntry<uint32_t>( { 0 })); localDataPoolMap.emplace(startracker::BLOBPIX_REGION, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(startracker::CAMERA_MODE, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::CAMERA_MODE, new PoolEntry<uint8_t>( { 0 }));
@ -1290,12 +1280,13 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_STORE, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_STORE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_SIGNALTHRESHOLD, localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_SIGNALTHRESHOLD,
new PoolEntry<uint16_t>( { 0 })); new PoolEntry<uint16_t>( { 0 }));
localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_DARKTHRESHOLD, localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_DARKTHRESHOLD, new PoolEntry<uint16_t>( {
new PoolEntry<uint16_t>({0})); 0 }));
localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION, localDataPoolMap.emplace(startracker::IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION,
new PoolEntry<uint8_t>( { 0 })); new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::CENTROIDING_ENABLE_FILTER, new PoolEntry<uint8_t>({0})); localDataPoolMap.emplace(startracker::CENTROIDING_ENABLE_FILTER,
new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::CENTROIDING_MAX_QUALITY, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::CENTROIDING_MAX_QUALITY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::CENTROIDING_DARK_THRESHOLD, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::CENTROIDING_DARK_THRESHOLD, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::CENTROIDING_MIN_QUALITY, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::CENTROIDING_MIN_QUALITY, new PoolEntry<float>( { 0 }));
@ -1310,37 +1301,43 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(startracker::CENTROIDING_TRANSMATRIX11, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::CENTROIDING_TRANSMATRIX11, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_MODE, new PoolEntry<uint32_t>( { 0 })); localDataPoolMap.emplace(startracker::LISA_MODE, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_PREFILTER_DIST_THRESHOLD, new PoolEntry<float>({0})); localDataPoolMap.emplace(startracker::LISA_PREFILTER_DIST_THRESHOLD,
localDataPoolMap.emplace(startracker::LISA_PREFILTER_ANGLE_THRESHOLD, new PoolEntry<float>({0})); new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_PREFILTER_ANGLE_THRESHOLD,
new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_FOV_WIDTH, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::LISA_FOV_WIDTH, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_FOV_HEIGHT, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::LISA_FOV_HEIGHT, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_FLOAT_STAR_LIMIT, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::LISA_FLOAT_STAR_LIMIT, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_CLOSE_STAR_LIMIT, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::LISA_CLOSE_STAR_LIMIT, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_CLOSE_STAR_COUNT, localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_CLOSE_STAR_COUNT,
new PoolEntry<float>( { 0 })); new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_FRACTION_CLOSE, localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_FRACTION_CLOSE, new PoolEntry<float>( {
new PoolEntry<float>({0})); 0 }));
localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_MEAN_SUM, new PoolEntry<float>({0})); localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_MEAN_SUM,
localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_DB_STAR_COUNT,
new PoolEntry<float>( { 0 })); new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_RATING_WEIGHT_DB_STAR_COUNT, new PoolEntry<float>( {
0 }));
localDataPoolMap.emplace(startracker::LISA_MAX_COMBINATIONS, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::LISA_MAX_COMBINATIONS, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_NR_STARS_STOP, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::LISA_NR_STARS_STOP, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::LISA_FRACTION_CLOSE_STOP, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::LISA_FRACTION_CLOSE_STOP, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::MATCHING_SQUARED_DISTANCE_LIMIT, new PoolEntry<float>({0})); localDataPoolMap.emplace(startracker::MATCHING_SQUARED_DISTANCE_LIMIT,
localDataPoolMap.emplace(startracker::MATCHING_SQUARED_SHIFT_LIMIT, new PoolEntry<float>({0})); new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::MATCHING_SQUARED_SHIFT_LIMIT,
new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::TRACKING_THIN_LIMIT, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::TRACKING_THIN_LIMIT, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::TRACKING_OUTLIER_THRESHOLD, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::TRACKING_OUTLIER_THRESHOLD, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::TRACKING_OUTLIER_THRESHOLD_QUEST, localDataPoolMap.emplace(startracker::TRACKING_OUTLIER_THRESHOLD_QUEST, new PoolEntry<float>( {
new PoolEntry<float>({0})); 0 }));
localDataPoolMap.emplace(startracker::TRACKING_TRACKER_CHOICE, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::TRACKING_TRACKER_CHOICE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::VALIDATION_STABLE_COUNT, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::VALIDATION_STABLE_COUNT, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::VALIDATION_MAX_DIFFERENCE, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::VALIDATION_MAX_DIFFERENCE, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(startracker::VALIDATION_MIN_TRACKER_CONFIDENCE, localDataPoolMap.emplace(startracker::VALIDATION_MIN_TRACKER_CONFIDENCE, new PoolEntry<float>( {
new PoolEntry<float>({0})); 0 }));
localDataPoolMap.emplace(startracker::VALIDATION_MIN_MATCHED_STARS, new PoolEntry<uint8_t>({0})); localDataPoolMap.emplace(startracker::VALIDATION_MIN_MATCHED_STARS,
new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::ALGO_MODE, new PoolEntry<uint8_t>( { 0 })); localDataPoolMap.emplace(startracker::ALGO_MODE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(startracker::ALGO_I2T_MIN_CONFIDENCE, new PoolEntry<float>( { 0 })); localDataPoolMap.emplace(startracker::ALGO_I2T_MIN_CONFIDENCE, new PoolEntry<float>( { 0 }));
@ -1658,7 +1655,8 @@ void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
break; break;
} }
default: default:
sif::debug << "StarTrackerHandler::handleEvent: Did not subscribe to this event" << std::endl; sif::debug << "StarTrackerHandler::handleEvent: Did not subscribe to this event"
<< std::endl;
break; break;
} }
} }
@ -1674,7 +1672,8 @@ ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData,
uint32_t address; uint32_t address;
size_t size = sizeof(address); size_t size = sizeof(address);
const uint8_t* addressPtr = commandData + ReadCmd::ADDRESS_OFFSET; const uint8_t* addressPtr = commandData + ReadCmd::ADDRESS_OFFSET;
result = SerializeAdapter::deSerialize(&address, addressPtr, &size, SerializeIF::Endianness::BIG); result = SerializeAdapter::deSerialize(&address, addressPtr, &size,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of address failed" sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of address failed"
<< std::endl; << std::endl;
@ -1695,8 +1694,7 @@ ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData,
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
} }
const uint8_t* filePtr = commandData + ReadCmd::FILE_OFFSET; const uint8_t* filePtr = commandData + ReadCmd::FILE_OFFSET;
std::string fullname = std::string fullname = std::string(reinterpret_cast<const char*>(filePtr),
std::string(reinterpret_cast<const char*>(filePtr),
commandDataLen - sizeof(address) - sizeof(region) - sizeof(length)); commandDataLen - sizeof(address) - sizeof(region) - sizeof(length));
result = strHelper->startFlashRead(fullname, region, address, length); result = strHelper->startFlashRead(fullname, region, address, length);
if (result != RETURN_OK) { if (result != RETURN_OK) {
@ -1739,7 +1737,8 @@ ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandDat
req.region = *commandData; req.region = *commandData;
size_t size = sizeof(req.code); size_t size = sizeof(req.code);
const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET; const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET;
result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size, SerializeIF::Endianness::BIG); result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
} }
@ -1761,8 +1760,8 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
req.region = *(commandData); req.region = *(commandData);
size_t size = sizeof(req.address); size_t size = sizeof(req.address);
const uint8_t* addressPtr = commandData + ChecksumCmd::ADDRESS_OFFSET; const uint8_t* addressPtr = commandData + ChecksumCmd::ADDRESS_OFFSET;
result = result = SerializeAdapter::deSerialize(&req.address, addressPtr, &size,
SerializeAdapter::deSerialize(&req.address, addressPtr, &size, SerializeIF::Endianness::BIG); SerializeIF::Endianness::BIG);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of address " sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of address "
<< "failed" << std::endl; << "failed" << std::endl;
@ -1770,8 +1769,8 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
} }
size = sizeof(req.length); size = sizeof(req.length);
const uint8_t* lengthPtr = commandData + ChecksumCmd::LENGTH_OFFSET; const uint8_t* lengthPtr = commandData + ChecksumCmd::LENGTH_OFFSET;
result = result = SerializeAdapter::deSerialize(&req.length, lengthPtr, &size,
SerializeAdapter::deSerialize(&req.length, lengthPtr, &size, SerializeIF::Endianness::BIG); SerializeIF::Endianness::BIG);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of length failed" sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of length failed"
<< std::endl; << std::endl;
@ -1800,7 +1799,8 @@ ReturnValue_t StarTrackerHandler::prepareSetTimeCommand(const uint8_t* commandDa
result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size, result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size,
SerializeIF::Endianness::BIG); SerializeIF::Endianness::BIG);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed" << std::endl; sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed"
<< std::endl;
return result; return result;
} }
uint32_t length = 0; uint32_t length = 0;
@ -1836,8 +1836,8 @@ ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* co
} }
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
struct UploadCentroidActionRequest req; struct UploadCentroidActionRequest req;
std::string jsonFileName = std::string jsonFileName = std::string(reinterpret_cast<const char*>(commandData),
std::string(reinterpret_cast<const char*>(commandData), commandDataLen); commandDataLen);
NVMParameterBase j(jsonFileName); NVMParameterBase j(jsonFileName);
result = j.readJsonFile(); result = j.readJsonFile();
if (result != RETURN_OK) { if (result != RETURN_OK) {
@ -1866,15 +1866,13 @@ ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* co
result = j.getValue(startracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected); result = j.getValue(startracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< startracker::UploadCentroidKeys::x_uncorrected << " does not exist" << startracker::UploadCentroidKeys::x_uncorrected << " does not exist" << std::endl;
<< std::endl;
return result; return result;
} }
result = j.getValue(startracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected); result = j.getValue(startracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< startracker::UploadCentroidKeys::y_uncorrected << " does not exist" << startracker::UploadCentroidKeys::y_uncorrected << " does not exist" << std::endl;
<< std::endl;
return result; return result;
} }
result = j.getValue(startracker::UploadCentroidKeys::x_corrected, &req.x_corrected); result = j.getValue(startracker::UploadCentroidKeys::x_corrected, &req.x_corrected);
@ -2024,8 +2022,7 @@ void StarTrackerHandler::prepareErrorResetRequest() {
} }
ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData, ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
size_t commandDataLen, size_t commandDataLen, ArcsecJsonParamBase& paramSet) {
ArcsecJsonParamBase& paramSet) {
ReturnValue_t result = RETURN_OK; ReturnValue_t result = RETURN_OK;
if (commandDataLen > MAX_PATH_SIZE) { if (commandDataLen > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG; return FILE_PATH_TOO_LONG;
@ -2333,7 +2330,8 @@ ReturnValue_t StarTrackerHandler::handleParamRequest(LocalPoolDataSetBase& datas
dataset.setValidityBufferGeneration(false); dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::handleParamRequest Deserialization failed" << std::endl; sif::warning << "StarTrackerHandler::handleParamRequest Deserialization failed"
<< std::endl;
} }
dataset.setValidityBufferGeneration(true); dataset.setValidityBufferGeneration(true);
dataset.setValidity(true, true); dataset.setValidity(true, true);
@ -2378,7 +2376,8 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
startupState = StartupState::DONE; startupState = StartupState::DONE;
} }
if (internalState == InternalState::VERIFY_BOOT) { if (internalState == InternalState::VERIFY_BOOT) {
sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware" << std::endl; sif::warning << "StarTrackerHandler::checkProgram: Failed to boot firmware"
<< std::endl;
// Device handler will run into timeout and fall back to transition source mode // Device handler will run into timeout and fall back to transition source mode
triggerEvent(BOOTING_FIRMWARE_FAILED); triggerEvent(BOOTING_FIRMWARE_FAILED);
internalState = InternalState::FAILED_FIRMWARE_BOOT; internalState = InternalState::FAILED_FIRMWARE_BOOT;
@ -2451,7 +2450,8 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dat
dataset.setValidityBufferGeneration(false); dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::handleActionReplySet Deserialization failed" << std::endl; sif::warning << "StarTrackerHandler::handleActionReplySet Deserialization failed"
<< std::endl;
} }
dataset.setValidityBufferGeneration(true); dataset.setValidityBufferGeneration(true);
dataset.setValidity(true, true); dataset.setValidity(true, true);

26
linux/devices/startracker/StrHelper.cpp
View File

@ -171,14 +171,22 @@ ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t region, uint32
return RETURN_OK; return RETURN_OK;
} }
void StrHelper::disableTimestamping() {
timestamping = false;
}
void StrHelper::enableTimestamping() {
timestamping = true;
}
ReturnValue_t StrHelper::performImageDownload() { ReturnValue_t StrHelper::performImageDownload() {
ReturnValue_t result; ReturnValue_t result;
struct DownloadActionRequest downloadReq; struct DownloadActionRequest downloadReq;
uint32_t size = 0; uint32_t size = 0;
uint32_t retries = 0; uint32_t retries = 0;
Timestamp timestamp; std::string image = makeFilename();
std::string image = downloadImage.path + "/" + timestamp.str() + downloadImage.filename; // std::ofstream file(image, std::ios_base::app | std::ios_base::out);
std::ofstream file(image, std::ios_base::app | std::ios_base::out); std::ofstream file(image, std::ios_base::out);
if (not std::filesystem::exists(image)) { if (not std::filesystem::exists(image)) {
return FILE_CREATION_FAILED; return FILE_CREATION_FAILED;
} }
@ -576,3 +584,15 @@ ReturnValue_t StrHelper::unlockAndEraseRegions(uint32_t from, uint32_t to) {
} }
return result; return result;
} }
std::string StrHelper::makeFilename() {
std::string image;
Timestamp timestamp;
if (timestamping) {
image = downloadImage.path + "/" + timestamp.str() + downloadImage.filename;
}
else {
image = downloadImage.path + "/" + downloadImage.filename;
}
return image;
}

18
linux/devices/startracker/StrHelper.h
View File

@ -139,6 +139,16 @@ class StrHelper : public SystemObject, public ExecutableObjectIF, public HasRetu
*/ */
void setFlashReadFilename(std::string filename); void setFlashReadFilename(std::string filename);
/**
* @brief Disables timestamp generation when new file is created
*/
void disableTimestamping();
/**
* @brief Enables timestamp generation when new file is created
*/
void enableTimestamping();
private: private:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER; static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER;
@ -254,6 +264,12 @@ class StrHelper : public SystemObject, public ExecutableObjectIF, public HasRetu
uint32_t nextProgressPrint = 0; uint32_t nextProgressPrint = 0;
#ifdef EGSE
bool timestamping = false;
#else
bool timestamping = true;
#endif
/** /**
* UART communication object responsible for low level access of star tracker * UART communication object responsible for low level access of star tracker
* Must be set by star tracker handler * Must be set by star tracker handler
@ -355,6 +371,8 @@ class StrHelper : public SystemObject, public ExecutableObjectIF, public HasRetu
* *
*/ */
ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to); ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to);
std::string makeFilename();
}; };
#endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */ #endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */

2
tmtc

@ -1 +1 @@
Subproject commit 0a8a2fb9c6833f2e1d89dabaf4c06bd79190fb50 Subproject commit fd43ef0c8a8241e7c50eea16ac86d9b121736ac1