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

fpga download image command
Some checks failed
EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit
Details

Browse Source
This commit is contained in:
Jakob Meier
2021-12-29 20:33:20 +01:00
parent 8d160572c7
commit e26ffb6afd
11 changed files with 1031 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

418
bsp_q7s/devices/startracker/StarTrackerHandler.cpp
View File

@ -1,23 +1,25 @@
#include <fstream>
#include "StarTrackerHandler.h"
#include "OBSWConfig.h"
#include "StarTrackerJsonCommands.h"
#include <fsfw/globalfunctions/CRC.h>
#include <fsfw/ipc/QueueFactory.h>
#include <mission/Memory/NVMParameterBase.h>
extern "C" {
#include <thirdparty/arcsec_star_tracker/client/generated/telemetry.h>
#include <thirdparty/arcsec_star_tracker/client/generated/actionreq.h>
#include "common/misc.h"
}
using json = nlohmann::json;
StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
CookieIF * comCookie, StrHelper* strHelper) :
DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet(
this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this),
contrastSet(this), checksumSet(this), strHelper(strHelper) {
this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), contrastSet(
this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this),
downloadDbImage(this), downloadBlobPixel(this), strHelper(
strHelper) {
if (comCookie == nullptr) {
sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
}
@ -51,7 +53,7 @@ ReturnValue_t StarTrackerHandler::initialize() {
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED),
event::getEventId(StrHelper::FLASH_READ_FAILED));
event::getEventId(StrHelper::FPGA_UPLOAD_FAILED));
if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from "
@ -173,6 +175,21 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
std::string(reinterpret_cast<const char*>(data), size));
return EXECUTION_FINISHED;
}
case(StarTracker::DOWNLOAD_FPGA_IMAGE): {
result = DeviceHandlerBase::acceptExternalDeviceCommands();
if (result != RETURN_OK) {
return result;
}
if (size > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG;
}
result = executeFpgaDownloadCommand(data, size);
if (result != RETURN_OK) {
return result;
}
strHelperExecuting = true;
return EXECUTION_FINISHED;
}
default:
break;
}
@ -428,6 +445,30 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
result = prepareChecksumCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::SET_TIME): {
result = prepareSetTimeCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::DOWNLOAD_CENTROID): {
result = prepareDownloadCentroidCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::UPLOAD_CENTROID): {
result = prepareUploadCentroidCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::DOWNLOAD_MATCHED_STAR): {
result = prepareDownloadMatchedStarCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::DOWNLOAD_DBIMAGE): {
result = prepareDownloadDbImageCommand(commandData, commandDataLen);
return result;
}
case (StarTracker::DOWNLOAD_BLOBPIXEL): {
result = prepareDownloadBlobPixelCommand(commandData, commandDataLen);
return result;
}
default:
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
}
@ -492,6 +533,18 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::CHECKSUM, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::SET_TIME, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_CENTROID, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::UPLOAD_CENTROID, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_MATCHED_STAR, 3, &downloadMatchedStar,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_DBIMAGE, 3, &downloadDbImage,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_BLOBPIXEL, 3, &downloadBlobPixel,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
}
ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize,
@ -563,10 +616,31 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con
case (StarTracker::BOOT):
case (StarTracker::TAKE_IMAGE):
case (StarTracker::RESET_ERROR):
case (StarTracker::UNLOCK): {
case (StarTracker::UNLOCK):
case (StarTracker::SET_TIME): {
result = handleActionReply();
break;
}
case (StarTracker::DOWNLOAD_CENTROID): {
result = handleActionReplySet(downloadCentroidSet, StarTracker::DownloadCentroidSet::SIZE);
break;
}
case (StarTracker::DOWNLOAD_MATCHED_STAR): {
result = handleActionReplySet(downloadMatchedStar, StarTracker::DownloadMatchedStar::SIZE);
break;
}
case (StarTracker::DOWNLOAD_DBIMAGE): {
result = handleActionReplySet(downloadDbImage, StarTracker::DownloadDBImage::SIZE);
break;
}
case (StarTracker::DOWNLOAD_BLOBPIXEL): {
result = handleActionReplySet(downloadBlobPixel, StarTracker::DownloadBlobPixel::SIZE);
break;
}
case (StarTracker::UPLOAD_CENTROID): {
result = handleUploadCentroidReply();
break;
}
case (StarTracker::ERASE): {
result = handleEraseReply();
break;
@ -796,6 +870,41 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(StarTracker::CONTRAST_BIND7, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::CONTRAST_BIND8, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::CHKSUM, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_ID, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_PIXX, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_PIXY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_X_UNCORRECTED, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_Y_UNCORRECTED, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_X_CORRECTED, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_Y_CORRECTED, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_MAGNITUDE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_CXA, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_CYA, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::DWL_QUALITY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_ID, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPX, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTX, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTZ, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMMAGNITUDE, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPX, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTX, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTY, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTZ, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBMAGNITUDE, new PoolEntry<float>( { 0 }));
localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CATALOGID, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::BLOBPIX_ID, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::BLOBPIX_X, 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_IN_USE, new PoolEntry<uint8_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::BLOBPIX_BRIGHT_NEIGHBOURS, new PoolEntry<uint32_t>( { 0 }));
localDataPoolMap.emplace(StarTracker::BLOBPIX_REGION, new PoolEntry<uint32_t>( { 0 }));
return RETURN_OK;
}
@ -862,6 +971,30 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId)
*foundId = StarTracker::CHECKSUM;
break;
}
case (StarTracker::ID::SET_TIME): {
*foundId = StarTracker::SET_TIME;
break;
}
case (StarTracker::ID::DOWNLOAD_CENTROID): {
*foundId = StarTracker::DOWNLOAD_CENTROID;
break;
}
case (StarTracker::ID::UPLOAD_CENTROID): {
*foundId = StarTracker::UPLOAD_CENTROID;
break;
}
case (StarTracker::ID::DOWNLOAD_MATCHED_STAR): {
*foundId = StarTracker::DOWNLOAD_MATCHED_STAR;
break;
}
case (StarTracker::ID::DOWNLOAD_DBIMAGE): {
*foundId = StarTracker::DOWNLOAD_DBIMAGE;
break;
}
case (StarTracker::ID::DOWNLOAD_BLOBPIXEL): {
*foundId = StarTracker::DOWNLOAD_BLOBPIXEL;
break;
}
default:
sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id"
<< std::endl;
@ -1019,6 +1152,46 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData
return result;
}
ReturnValue_t StarTrackerHandler::executeFpgaDownloadCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
if (commandDataLen < FpgaDownloadCmd::MIN_LENGTH) {
sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Command too short"
<< std::endl;
return COMMAND_TOO_SHORT;
}
uint32_t position;
size_t size = sizeof(position);
result = SerializeAdapter::deSerialize(&position, &commandData, &size,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of position failed"
<< std::endl;
return result;
}
uint32_t length;
size = sizeof(length);
result = SerializeAdapter::deSerialize(&length, &commandData, &size,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of length failed"
<< std::endl;
return result;
}
if (commandDataLen - sizeof(position) - sizeof(length) > MAX_PATH_SIZE) {
sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Received command with "
" invalid path and filename" << std::endl;
return FILE_PATH_TOO_LONG;
}
std::string fullname = std::string(reinterpret_cast<const char*>(commandData),
commandDataLen - sizeof(position) - sizeof(length));
result = strHelper->startFpgaDownload(fullname, position, length);
if (result != RETURN_OK) {
return result;
}
return result;
}
ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
@ -1146,6 +1319,140 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
return result;
}
ReturnValue_t StarTrackerHandler::prepareSetTimeCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
struct SetTimeActionRequest req;
if (commandDataLen != SetTimeCmd::LENGTH) {
sif::warning << "StarTrackerHandler::prepareSetTimeCommand: Invalid length" << std::endl;
return INVALID_LENGTH;
}
size_t size = sizeof(req.unixTime);
result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size,
SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed"
<< std::endl;
return result;
}
uint32_t length = 0;
arc_pack_settime_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return result;
}
ReturnValue_t StarTrackerHandler::prepareDownloadCentroidCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
struct DownloadCentroidActionRequest req;
if (commandDataLen != DownloadCentroidCmd::LENGTH) {
sif::warning << "StarTrackerHandler::prepareDownloadCentroidCommand: Invalid length"
<< std::endl;
return INVALID_LENGTH;
}
req.id = *commandData;
uint32_t length = 0;
arc_pack_downloadcentroid_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return result;
}
ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* commandData,
size_t commandDataLen) {
if (commandDataLen > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG;
}
ReturnValue_t result = RETURN_OK;
struct UploadCentroidActionRequest req;
std::string jsonFileName = std::string(reinterpret_cast<const char*>(commandData),
commandDataLen);
NVMParameterBase j(jsonFileName);
result = j.readJsonFile();
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: " << jsonFileName
<< " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::id, &req.id);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::id << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::pixx, &req.pixx);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::pixx << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::pixy, &req.pixy);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::pixy << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::x_uncorrected << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::y_uncorrected << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::x_corrected, &req.x_corrected);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::x_corrected << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::y_corrected, &req.y_corrected);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::y_corrected << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::magnitude, &req.magnitude);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::magnitude << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::cxa, &req.cxa);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::cxa << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::cya, &req.cya);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::cya << " does not exist" << std::endl;
return result;
}
result = j.getValue(StarTracker::UploadCentroidKeys::quality, &req.quality);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key "
<< StarTracker::UploadCentroidKeys::quality << " does not exist" << std::endl;
return result;
}
uint32_t length = 0;
arc_pack_uploadcentroid_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
uploadCentroid.rememberId = req.id;
return result;
}
void StarTrackerHandler::prepareTimeRequest() {
uint32_t length = 0;
arc_tm_pack_time_req(commandBuffer, &length);
@ -1293,6 +1600,55 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::prepareDownloadMatchedStarCommand(const uint8_t* commandData,
size_t commandDataLen) {
if (commandDataLen != DownloadMatchedStarCmd::LENGTH) {
return INVALID_LENGTH;
}
struct DownloadMatchedStarActionRequest req;
req.id = *commandData;
uint32_t length = 0;
arc_pack_downloadmatchedstar_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::prepareDownloadDbImageCommand(const uint8_t* commandData,
size_t commandDataLen) {
if (commandDataLen != DownloadDbImageCmd::LENGTH) {
return INVALID_LENGTH;
}
struct DownloadDBImageActionRequest req;
req.id = *commandData;
uint32_t length = 0;
arc_pack_downloaddbimage_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::prepareDownloadBlobPixelCommand(const uint8_t* commandData,
size_t commandDataLen) {
if (commandDataLen != DownloadBlobPixCmd::LENGTH) {
return INVALID_LENGTH;
}
struct DownloadBlobPixelActionRequest req;
req.id = *commandData;
req.type = *(commandData + 1);
if ((req.type != DownloadBlobPixCmd::NORMAL) && (req.type != DownloadBlobPixCmd::FAST)) {
return INVALID_TYPE;
}
uint32_t length = 0;
arc_pack_downloadblobpixel_action_req(&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);
@ -1316,7 +1672,7 @@ ReturnValue_t StarTrackerHandler::handleActionReply() {
uint8_t status = *(reply + STATUS_OFFSET);
if (status != StarTracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action "
<< " command with action ID "
<< "command with action ID "
<< static_cast<unsigned int>(*(reply + ACTION_ID_OFFSET))
<< " and status "<< static_cast<unsigned int>(status) << std::endl;
return ACTION_FAILED;
@ -1324,6 +1680,19 @@ ReturnValue_t StarTrackerHandler::handleActionReply() {
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::handleUploadCentroidReply() {
ReturnValue_t result = RETURN_OK;
result = handleActionReply();
if (result != RETURN_OK) {
return result;
}
const uint8_t* reply = dataLinkLayer.getReply();
if (*(reply + ACTION_DATA_OFFSET) != uploadCentroid.rememberId) {
return UPLOAD_CENTROID_ID_MISMATCH;
}
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::handleEraseReply() {
ReturnValue_t result = RETURN_OK;
result = handleActionReply();
@ -1422,7 +1791,7 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
if(status != StarTracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleTm: Reply error: "
<< static_cast<unsigned int>(status) << std::endl;
return TM_REPLY_ERROR;
return REPLY_ERROR;
}
result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
if (result != RETURN_OK) {
@ -1447,6 +1816,37 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t
return result;
}
ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size) {
ReturnValue_t result = RETURN_OK;
uint8_t status = *(dataLinkLayer.getReply() + STATUS_OFFSET);
if(status != StarTracker::STATUS_OK) {
sif::warning << "StarTrackerHandler::handleActionReplySet: Reply error: "
<< static_cast<unsigned int>(status) << std::endl;
return REPLY_ERROR;
}
result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
if (result != RETURN_OK) {
return result;
}
const uint8_t* reply = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
dataset.setValidityBufferGeneration(false);
result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::handleActionReplySet Deserialization failed"
<< std::endl;
}
dataset.setValidityBufferGeneration(true);
dataset.setValidity(true, true);
result = dataset.commit(TIMEOUT_TYPE, MUTEX_TIMEOUT);
if (result != RETURN_OK) {
return result;
}
#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1
dataset.printSet();
#endif
return result;
}
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
switch(*parameterId) {
case (StarTracker::ID::LIMITS): {