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

refactored star tracker handler

Browse Source
This commit is contained in:
Jakob Meier
2022-02-27 15:46:06 +01:00
parent e61dfc0401
commit dfd817d27b
12 changed files with 87 additions and 3205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,8 +1,6 @@
#include "StarTrackerHandler.h"
#include <fsfw/globalfunctions/CRC.h>
#include <fsfw/ipc/QueueFactory.h>
#include <mission/memory/NVMParameterBase.h>
#include <fstream>
@ -12,12 +10,9 @@ extern "C" {
#include <thirdparty/arcsec_star_tracker/client/generated/actionreq.h>
#include <thirdparty/arcsec_star_tracker/client/generated/parameter.h>
#include <thirdparty/arcsec_star_tracker/client/generated/telemetry.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),
@ -28,12 +23,7 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
timeSet(this),
solutionSet(this),
histogramSet(this),
contrastSet(this),
checksumSet(this),
downloadCentroidSet(this),
downloadMatchedStar(this),
downloadDbImage(this),
downloadBlobPixel(this),
cameraSet(this),
limitsSet(this),
loglevelSet(this),
@ -117,10 +107,10 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
}
case (startracker::DISABLE_TIMESTAMP_GENERATION):
strHelper->disableTimestamping();
break;
return EXECUTION_FINISHED;
case (startracker::ENABLE_TIMESTAMP_GENERATION):
strHelper->enableTimestamping();
break;
return EXECUTION_FINISHED;
default:
break;
}
@ -184,18 +174,18 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
strHelperExecuting = true;
return EXECUTION_FINISHED;
}
case (startracker::CHANGE_DOWNLOAD_FILE): {
case (startracker::CHANGE_IMAGE_DOWNLOAD_FILE): {
if (size > MAX_FILE_NAME) {
return FILENAME_TOO_LONG;
}
strHelper->setDownloadImageName(std::string(reinterpret_cast<const char*>(data), size));
return EXECUTION_FINISHED;
}
case (startracker::SET_READ_FILENAME): {
case (startracker::SET_FLASH_READ_FILENAME): {
if (size > MAX_FILE_NAME) {
return FILENAME_TOO_LONG;
}
strHelper->setDownloadImageName(std::string(reinterpret_cast<const char*>(data), size));
strHelper->setFlashReadFilename(std::string(reinterpret_cast<const char*>(data), size));
return EXECUTION_FINISHED;
}
case (startracker::FIRMWARE_UPDATE): {
@ -272,11 +262,16 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
switch (normalState) {
case NormalState::TEMPERATURE_REQUEST:
*id = startracker::REQ_TEMPERATURE;
normalState = NormalState::SOLUTION_REQUEST;
break;
case NormalState::SOLUTION_REQUEST:
*id = startracker::REQ_SOLUTION;
normalState = NormalState::TEMPERATURE_REQUEST;
break;
default:
sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid normal step"
<< std::endl;
break;
return NOTHING_TO_SEND;
}
return buildCommandFromCommand(*id, NULL, 0);
}
@ -415,7 +410,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
return RETURN_OK;
}
case (startracker::SWITCH_TO_BOOTLOADER_PROGRAM): {
prepareRebootCommand();
prepareSwitchToBootloaderCmd();
return RETURN_OK;
}
case (startracker::TAKE_IMAGE): {
@ -439,14 +434,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
prepareHistogramRequest();
return RETURN_OK;
}
case (startracker::REQ_CONTRAST): {
prepareContrastRequest();
return RETURN_OK;
}
case (startracker::RESET_ERROR): {
prepareErrorResetRequest();
return RETURN_OK;
}
case (startracker::LIMITS): {
Limits limits;
result = prepareParamCommand(commandData, commandDataLen, limits);
@ -512,42 +499,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
result = prepareParamCommand(commandData, commandDataLen, debugCamera);
return result;
}
case (startracker::ERASE): {
result = prepareEraseCommand(commandData, commandDataLen);
return result;
}
case (startracker::UNLOCK): {
result = prepareUnlockCommand(commandData, commandDataLen);
return result;
}
case (startracker::CHECKSUM): {
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;
}
case (startracker::REQ_CAMERA): {
result = prepareRequestCameraParams();
return result;
@ -636,8 +591,6 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::REQ_HISTOGRAM, 3, &histogramSet,
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,
@ -652,8 +605,6 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::CENTROIDING, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::LISA, 3, nullptr,
@ -668,25 +619,7 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::TAKE_IMAGE, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::RESET_ERROR, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::ERASE, 3, nullptr,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::UNLOCK, 3, nullptr,
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,
this->insertInCommandAndReplyMap(startracker::CHECKSUM, 3, &checksumSet,
startracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(startracker::REQ_CAMERA, 3, &cameraSet,
startracker::MAX_FRAME_SIZE * 2 + 2);
@ -890,34 +823,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
}
case (startracker::BOOT):
case (startracker::TAKE_IMAGE):
case (startracker::RESET_ERROR):
case (startracker::UNLOCK):
case (startracker::SET_TIME):
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;
}
case (startracker::CHECKSUM): {
result = handleChecksumReply();
break;
@ -953,10 +859,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
result = handleTm(histogramSet, startracker::HistogramSet::SIZE);
break;
}
case (startracker::REQ_CONTRAST): {
result = handleTm(contrastSet, startracker::ContrastSet::SIZE);
break;
}
case (startracker::SUBSCRIPTION):
case (startracker::LOGLEVEL):
case (startracker::LOGSUBSCRIPTION):
@ -1042,11 +944,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
void StarTrackerHandler::setNormalDatapoolEntriesInvalid() {}
uint32_t StarTrackerHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
// if (modeTo == MODE_ON && (submode == SUBMODE_NONE || submode == SUBMODE_BOOTLOADER)) {
// return BOOTLOADER_TRANSITION_DELAY;
// } else if (modeTo == MODE_ON && submode == SUBMODE_FIRMWARE && modeFrom == MODE_) {
// return FIRMWARE_TRANSITION_DELAY;
// }
return DEFAULT_TRANSITION_DELAY;
}
@ -1164,82 +1061,6 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(startracker::HISTOGRAM_BIND7, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::HISTOGRAM_BIND8, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::TICKS_CONTRAST_SET, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::TIME_CONTRAST_SET, new PoolEntry<uint64_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA0, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA1, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA2, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA3, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA4, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA5, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA6, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA7, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINA8, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB0, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB1, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB2, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB3, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB4, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB5, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB6, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB7, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINB8, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC8, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC0, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC1, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC2, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC3, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC4, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC5, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC6, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC7, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BINC8, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND0, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND1, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND2, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND3, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND4, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND5, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CONTRAST_BIND6, new PoolEntry<uint32_t>({0}));
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}));
localDataPoolMap.emplace(startracker::CAMERA_MODE, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(startracker::FOCALLENGTH, new PoolEntry<float>({0}));
localDataPoolMap.emplace(startracker::EXPOSURE, new PoolEntry<float>({0}));
@ -1384,6 +1205,8 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(startracker::DEBUG_CAMERA_TIMING, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::DEBUG_CAMERA_TEST, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(startracker::CHKSUM, new PoolEntry<uint32_t>({0}));
return RETURN_OK;
}
@ -1432,46 +1255,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId)
*foundId = startracker::UPLOAD_IMAGE;
break;
}
case (startracker::ID::ERROR_RESET): {
*foundId = startracker::RESET_ERROR;
break;
}
case (startracker::ID::ERASE): {
*foundId = startracker::ERASE;
break;
}
case (startracker::ID::UNLOCK): {
*foundId = startracker::UNLOCK;
break;
}
case (startracker::ID::CHECKSUM): {
*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::scanForActionReply: Unknown parameter reply id"
<< std::endl;
@ -1638,10 +1425,6 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
*foundId = startracker::REQ_HISTOGRAM;
break;
}
case (startracker::ID::CONTRAST): {
*foundId = startracker::REQ_CONTRAST;
break;
}
case (startracker::ID::TIME): {
*foundId = startracker::REQ_TIME;
break;
@ -1678,7 +1461,7 @@ void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
ReturnValue_t StarTrackerHandler::executeFlashReadCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
if (commandDataLen < ReadCmd::MIN_LENGTH) {
if (commandDataLen < FlashReadCmd::MIN_LENGTH) {
sif::warning << "StarTrackerHandler::executeFlashReadCommand: Command too short" << std::endl;
return COMMAND_TOO_SHORT;
}
@ -1716,42 +1499,6 @@ void StarTrackerHandler::prepareBootCommand() {
rawPacketLen = dataLinkLayer.getEncodedLength();
}
ReturnValue_t StarTrackerHandler::prepareEraseCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
if (commandDataLen != EraseCmd::LENGTH) {
return INVALID_LENGTH;
}
uint32_t length = 0;
struct EraseActionRequest req;
req.region = *commandData;
arc_pack_erase_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
eraseCmd.rememberRegion = req.region;
return result;
}
ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
uint32_t length = 0;
struct UnlockActionRequest req;
req.region = *commandData;
size_t size = sizeof(req.code);
const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET;
result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size, SerializeIF::Endianness::BIG);
if (result != RETURN_OK) {
return result;
}
arc_pack_unlock_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return result;
}
ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData,
size_t commandDataLen) {
struct ChecksumActionRequest req;
@ -1790,140 +1537,6 @@ 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);
@ -1965,7 +1578,7 @@ void StarTrackerHandler::preparePowerRequest() {
rawPacketLen = dataLinkLayer.getEncodedLength();
}
void StarTrackerHandler::prepareRebootCommand() {
void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
uint32_t length = 0;
struct RebootActionRequest rebootReq;
arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
@ -2008,23 +1621,6 @@ void StarTrackerHandler::prepareHistogramRequest() {
rawPacketLen = dataLinkLayer.getEncodedLength();
}
void StarTrackerHandler::prepareContrastRequest() {
uint32_t length = 0;
arc_tm_pack_contrast_req(commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
}
void StarTrackerHandler::prepareErrorResetRequest() {
uint32_t length = 0;
struct ResetErrorSignalActionRequest req;
arc_pack_reseterrorsignal_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
}
ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
size_t commandDataLen,
ArcsecJsonParamBase& paramSet) {
@ -2044,73 +1640,6 @@ 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::prepareFpgaActionCommand(const uint8_t* commandData,
size_t commandDataLen) {
if (commandDataLen != FpgaActionCmd::LENGTH) {
return INVALID_LENGTH;
}
struct FPGAActionActionRequest req;
req.id = *commandData;
if (req.id != FpgaActionCmd::ID) {
return INVALID_ID;
}
uint32_t length = 0;
arc_pack_fpgaaction_action_req(&req, commandBuffer, &length);
dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = dataLinkLayer.getEncodedFrame();
rawPacketLen = dataLinkLayer.getEncodedLength();
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::prepareRequestCameraParams() {
uint32_t length = 0;
arc_pack_camera_parameter_req(commandBuffer, &length);
@ -2268,34 +1797,6 @@ 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();
if (result != RETURN_OK) {
return result;
}
const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET;
startracker::EraseReply eraseReply(replyData);
if (eraseReply.getRegion() != eraseCmd.rememberRegion) {
sif::warning << "StarTrackerHandler::handleEraseReply: Region mismatch" << std::endl;
return REGION_MISMATCH;
}
return result;
}
ReturnValue_t StarTrackerHandler::handleChecksumReply() {
ReturnValue_t result = RETURN_OK;
result = handleActionReply();
@ -2538,21 +2039,30 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
case startracker::UPLOAD_IMAGE:
case startracker::REQ_POWER:
case startracker::TAKE_IMAGE:
case startracker::DOWNLOAD_CENTROID:
case startracker::UPLOAD_CENTROID:
case startracker::REQ_SOLUTION:
case startracker::REQ_TEMPERATURE:
case startracker::REQ_HISTOGRAM:
case startracker::REQ_CONTRAST:
case startracker::DOWNLOAD_MATCHED_STAR:
case startracker::DOWNLOAD_DBIMAGE:
case startracker::DOWNLOAD_BLOBPIXEL:
if (!(mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
case startracker::REQ_CAMERA:
case startracker::REQ_LIMITS:
case startracker::REQ_LOG_LEVEL:
case startracker::REQ_MOUNTING:
case startracker::REQ_IMAGE_PROCESSOR:
case startracker::REQ_CENTROIDING:
case startracker::REQ_LISA:
case startracker::REQ_MATCHING:
case startracker::REQ_TRACKING:
case startracker::REQ_VALIDATION:
case startracker::REQ_ALGO:
case startracker::REQ_SUBSCRIPTION:
case startracker::REQ_LOG_SUBSCRIPTION:
case startracker::REQ_DEBUG_CAMERA:
if (not (mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
return STARTRACKER_RUNNING_BOOTLOADER;
}
break;
case startracker::FIRMWARE_UPDATE:
if (!(mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
case startracker::FLASH_READ:
if (not (mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
return STARTRACKER_RUNNING_FIRMWARE;
}
break;