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

removed blob command

Browse Source
This commit is contained in:
Jakob Meier 2022-01-29 12:27:26 +01:00
parent 6be7cb4d0c
commit 6043a827ed
10 changed files with 114 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
bsp_q7s/devices/startracker/ArcsecJsonKeys.h
View File

@ -28,6 +28,13 @@ static const char qx[] = "qx";
static const char qy[] = "qy";
static const char qz[] = "qz";
static const char IMAGE_PROCESSOR[] = "imageprocessor";
static const char IMAGE_PROCESSOR_MODE[] = "mode";
static const char STORE[] = "store";
static const char SIGNAL_THRESHOLD[] = "signalThreshold";
static const char IMAGE_PROCESSOR_DARK_THRESHOLD[] = "darkThreshold";
static const char BACKGROUND_COMPENSATION[] = "backgroundcompensation";
static const char CAMERA[] = "camera";
static const char MODE[] = "mode";
static const char FOCALLENGTH[] = "focallength";
@ -64,7 +71,7 @@ static const char MAX_TOTAL_VALUE[] = "maxTotalValue";
static const char MIN_BRIGHT_NEIGHBOURS[] = "minBrightNeighbours";
static const char MAX_BRIGHT_NEIGHBOURS[] = "maxBrightNeighbours";
static const char MAX_PIXEL_TO_CONSIDER[] = "maxPixelsToConsider";
static const char SIGNAL_THRESHOLD[] = "signalThreshold";
//static const char SIGNAL_THRESHOLD[] = "signalThreshold";
static const char BLOB_DARK_THRESHOLD[] = "darkThreshold";
static const char ENABLE_HISTOGRAM[] = "enableHistogram";
static const char ENABLE_CONTRAST[] = "enableContrast";

2
bsp_q7s/devices/startracker/ArcsecJsonParamBase.cpp
View File

@ -97,5 +97,7 @@ ReturnValue_t ArcsecJsonParamBase::initSet() {
return RETURN_OK;
}
}
sif::warning << "ArcsecJsonParamBase::initSet: Set " << setName << "not present in json file"
<< std::endl;
return SET_NOT_EXISTS;
}

87
bsp_q7s/devices/startracker/StarTrackerDefinitions.h
View File

@ -60,6 +60,7 @@ enum PoolIds : lp_id_t {
TIME_TEMPERATURE_SET,
MCU_TEMPERATURE,
CMOS_TEMPERATURE,
FPGA_TEMPERATURE,
TICKS_SOLUTION_SET,
TIME_SOLUTION_SET,
CALI_QW,
@ -257,6 +258,7 @@ 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 IMAGE_PROCESSOR = 19;
static const DeviceCommandId_t REQ_SOLUTION = 24;
static const DeviceCommandId_t REQ_TEMPERATURE = 25;
static const DeviceCommandId_t REQ_HISTOGRAM = 28;
@ -264,7 +266,6 @@ static const DeviceCommandId_t REQ_CONTRAST = 29;
static const DeviceCommandId_t LIMITS = 40;
static const DeviceCommandId_t MOUNTING = 41;
static const DeviceCommandId_t CAMERA = 42;
static const DeviceCommandId_t BLOB = 43;
static const DeviceCommandId_t CENTROIDING = 44;
static const DeviceCommandId_t LISA = 45;
static const DeviceCommandId_t MATCHING = 46;
@ -289,7 +290,6 @@ static const DeviceCommandId_t UPLOAD_FPGA_IMAGE = 65;
static const DeviceCommandId_t FPGA_ACTION = 66;
static const DeviceCommandId_t REQ_CAMERA = 67;
static const DeviceCommandId_t REQ_LIMITS = 68;
static const DeviceCommandId_t REQ_BLOB_PARAMS = 69;
static const DeviceCommandId_t NONE = 0xFFFFFFFF;
static const uint32_t VERSION_SET_ID = REQ_VERSION;
@ -307,12 +307,11 @@ static const uint32_t DOWNLOAD_DBIMAGE_SET_ID = DOWNLOAD_DBIMAGE;
static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL;
static const uint32_t CAMERA_SET_ID = REQ_CAMERA;
static const uint32_t LIMITS_SET_ID = REQ_LIMITS;
static const uint32_t BLOB_SET_ID = REQ_BLOB_PARAMS;
/** Max size of unencoded frame */
static const size_t MAX_FRAME_SIZE = 1200;
static const uint8_t TEMPERATURE_SET_ENTRIES = 4;
static const uint8_t TEMPERATURE_SET_ENTRIES = 5;
static const uint8_t VERSION_SET_ENTRIES = 5;
static const uint8_t INTERFACE_SET_ENTRIES = 4;
static const uint8_t POWER_SET_ENTRIES = 18;
@ -327,7 +326,6 @@ static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6;
static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7;
static const uint8_t CAMERA_SET_ENTRIES = 15;
static const uint8_t LIMITS_SET_ENTRIES = 11;
static const uint8_t BLOB_SET_ENTRIES = 15;
// Action, parameter and telemetry IDs
namespace ID {
@ -337,8 +335,8 @@ static const uint8_t VERSION = 2;
static const uint8_t INTERFACE = 3;
static const uint8_t LIMITS = 5;
static const uint8_t MOUNTING = 6;
static const uint8_t IMAGE_PROCESSOR = 10;
static const uint8_t CAMERA = 9;
static const uint8_t BLOB = 10;
static const uint8_t CENTROIDING = 11;
static const uint8_t LISA = 12;
static const uint8_t MATCHING = 13;
@ -351,7 +349,7 @@ static const uint8_t POWER = 11;
static const uint8_t SET_TIME = 14;
static const uint8_t SUBSCRIBE = 18;
static const uint8_t SOLUTION = 24;
static const uint8_t TEMPERATURE = 25;
static const uint8_t TEMPERATURE = 27;
static const uint8_t HISTOGRAM = 28;
static const uint8_t CONTRAST = 29;
static const uint8_t TIME = 1;
@ -380,7 +378,7 @@ static const uint8_t FIRMWARE = 2;
*/
class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
public:
static const size_t SIZE = 20;
static const size_t SIZE = 24;
TemperatureSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEMPERATURE_SET_ID) {}
@ -392,14 +390,17 @@ class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_TEMPERATURE_SET, this);
lp_var_t<float> mcuTemperature = lp_var_t<float>(sid.objectId, PoolIds::MCU_TEMPERATURE, this);
lp_var_t<float> cmosTemperature = lp_var_t<float>(sid.objectId, PoolIds::CMOS_TEMPERATURE, this);
lp_var_t<float> fpgaTemperature = lp_var_t<float>(sid.objectId, PoolIds::FPGA_TEMPERATURE, this);
void printSet() {
sif::info << "TemperatureSet::printSet: Ticks: " << this->ticks << std::endl;
sif::info << "TemperatureSet::printSet: Time: " << this->time << " us" << std::endl;
sif::info << "TemperatureSet::printSet: MCU Temperature: " << this->mcuTemperature << " °C"
<< std::endl;
sif::info << "TemperatureSet::printSet: CMOS Temperature: " << this->cmosTemperature << " °C"
sif::info << "TemperatureSet::printSet: CMOS Temperature (raw): " << this->cmosTemperature
<< std::endl;
sif::info << "TemperatureSet::printSet: FPGA Temperature (random value): "
<< this->fpgaTemperature << " °C" << std::endl;
}
};
@ -1201,73 +1202,5 @@ class LimitsSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
sif::info << "CameraSet::printSet: CMOSTemperature: " << this->cmosTemperature << std::endl;
}
};
/**
* @brief Will store the request of the blob parameters.
*/
class BlobSet : public StaticLocalDataSet<BLOB_SET_ENTRIES> {
public:
// Size of dataset
static const size_t SIZE = 22;
BlobSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOB_SET_ID) {}
BlobSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, BLOB_SET_ID)) {}
lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MODE, this);
lp_var_t<uint8_t> minValue = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MIN_VALUE, this);
lp_var_t<uint8_t> minDistance = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_MIN_DISTANCE, this);
lp_var_t<uint8_t> neighbourDistance =
lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_NEIGHBOUR_DISTANCE, this);
lp_var_t<uint8_t> neighbourBrightPixels =
lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_NEIGHBOUR_BRIGHTPIXELS, this);
lp_var_t<uint16_t> minTotalValue =
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MIN_TOTAL_VALUE, this);
lp_var_t<uint16_t> maxTotalValue =
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MAX_TOTAL_VALUE, this);
lp_var_t<uint16_t> minBrightNeighbours =
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MIN_BRIGHT_NEIGHBOURS, this);
lp_var_t<uint16_t> maxBrightNeighbours =
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOB_MAX_BRIGHT_NEIGHBOURS, this);
lp_var_t<uint32_t> maxPixelsToConsider =
lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_MAX_PIXELSTOCONSIDER, this);
lp_var_t<uint8_t> signalThreshold =
lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_SIGNAL_THRESHOLD, this);
lp_var_t<uint8_t> darkThreshold =
lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_DARK_THRESHOLD, this);
lp_var_t<uint8_t> enableContrast =
lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_ENABLE_CONTRAST, this);
lp_var_t<uint8_t> enableBinMode = lp_var_t<uint8_t>(sid.objectId, PoolIds::BLOB_BIN_MODE, this);
void printSet() {
PoolReadGuard rg(this);
sif::info << "BlobSet::printSet: mode: " << static_cast<unsigned int>(this->mode.value)
<< std::endl;
sif::info << "BlobSet::printSet: minValue: " << static_cast<unsigned int>(this->minValue.value)
<< std::endl;
sif::info << "BlobSet::printSet: minDistance: "
<< static_cast<unsigned int>(this->minDistance.value) << std::endl;
sif::info << "BlobSet::printSet: neighboutDistance: "
<< static_cast<unsigned int>(this->neighbourDistance.value) << std::endl;
sif::info << "BlobSet::printSet: neighboutBrightPixels: "
<< static_cast<unsigned int>(this->neighbourBrightPixels.value) << std::endl;
sif::info << "BlobSet::printSet: minTotalValue: " << this->minTotalValue << std::endl;
sif::info << "BlobSet::printSet: maxTotalValue: " << this->maxTotalValue << std::endl;
sif::info << "BlobSet::printSet: minBrightNeighbours: " << this->minBrightNeighbours
<< std::endl;
sif::info << "BlobSet::printSet: maxBrightNeighbours: " << this->maxBrightNeighbours
<< std::endl;
sif::info << "BlobSet::printSet: maxPixelsToConsider: " << this->maxPixelsToConsider
<< std::endl;
sif::info << "BlobSet::printSet: signalThreshold: "
<< static_cast<unsigned int>(this->signalThreshold.value) << std::endl;
sif::info << "BlobSet::printSet: darkThreshold: "
<< static_cast<unsigned int>(this->darkThreshold.value) << std::endl;
sif::info << "BlobSet::printSet: enableContrast: "
<< static_cast<unsigned int>(this->enableContrast.value) << std::endl;
sif::info << "BlobSet::printSet: enableBinMode: "
<< static_cast<unsigned int>(this->enableBinMode.value) << std::endl;
}
};
} // namespace StarTracker
#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */

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

@ -12,7 +12,6 @@ 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"
}
@ -109,7 +108,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
}
if (strHelperExecuting == true) {
return IMAGE_LOADER_EXECUTING;
return STR_HELPER_EXECUTING;
}
result = checkMode(actionId);
@ -316,16 +315,16 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
*id = StarTracker::MOUNTING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::IMAGE_PROCESSOR:
startupState = StartupState::WAIT_FOR_EXECUTION;
*id = StarTracker::IMAGE_PROCESSOR;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
case StartupState::CAMERA:
startupState = StartupState::WAIT_FOR_EXECUTION;
*id = StarTracker::CAMERA;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size());
// case StartupState::BLOB:
// startupState = StartupState::WAIT_FOR_EXECUTION;
// *id = StarTracker::BLOB;
// return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
// paramJsonFile.size());
case StartupState::CENTROIDING:
startupState = StartupState::WAIT_FOR_EXECUTION;
*id = StarTracker::CENTROIDING;
@ -428,16 +427,16 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
result = prepareParamCommand(commandData, commandDataLen, mounting);
return result;
}
case (StarTracker::IMAGE_PROCESSOR): {
ImageProcessor imageProcessor;
result = prepareParamCommand(commandData, commandDataLen, imageProcessor);
return result;
}
case (StarTracker::CAMERA): {
Camera camera;
result = prepareParamCommand(commandData, commandDataLen, camera);
return result;
}
case (StarTracker::BLOB): {
Blob blob;
result = prepareParamCommand(commandData, commandDataLen, blob);
return result;
}
case (StarTracker::CENTROIDING): {
Centroiding centroiding;
result = prepareParamCommand(commandData, commandDataLen, centroiding);
@ -558,9 +557,9 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::MOUNTING, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::CAMERA, 3, nullptr,
this->insertInCommandAndReplyMap(StarTracker::IMAGE_PROCESSOR, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::BLOB, 3, nullptr,
this->insertInCommandAndReplyMap(StarTracker::CAMERA, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::CENTROIDING, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2);
@ -751,12 +750,12 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
case (StarTracker::LIMITS):
case (StarTracker::MOUNTING):
case (StarTracker::CAMERA):
case (StarTracker::BLOB):
case (StarTracker::CENTROIDING):
case (StarTracker::LISA):
case (StarTracker::MATCHING):
case (StarTracker::TRACKING):
case (StarTracker::VALIDATION):
case (StarTracker::IMAGE_PROCESSOR):
case (StarTracker::ALGO): {
result = handleSetParamReply();
break;
@ -769,10 +768,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE);
break;
}
case (StarTracker::REQ_BLOB_PARAMS): {
handleParamRequest(blobSet, StarTracker::BlobSet::SIZE);
break;
}
default: {
sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id
<< std::endl;
@ -836,6 +831,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(StarTracker::TIME_TEMPERATURE_SET, new PoolEntry<uint64_t>({0}));
localDataPoolMap.emplace(StarTracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::CMOS_TEMPERATURE, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::FPGA_TEMPERATURE, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::TICKS_SOLUTION_SET, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(StarTracker::TIME_SOLUTION_SET, new PoolEntry<uint64_t>({0}));
@ -1002,23 +998,6 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
localDataPoolMap.emplace(StarTracker::LIMITS_CMOS33CURRENT, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::LIMITS_CMOSVRESCURRENT, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::LIMITS_CMOSTEMPERATURE, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MODE, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MIN_VALUE, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MIN_DISTANCE, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_DISTANCE, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_BRIGHTPIXELS, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_NEIGHBOUR_BRIGHTPIXELS, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MIN_TOTAL_VALUE, new PoolEntry<uint16_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MAX_TOTAL_VALUE, new PoolEntry<uint16_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MIN_BRIGHT_NEIGHBOURS, new PoolEntry<uint16_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MAX_BRIGHT_NEIGHBOURS, new PoolEntry<uint16_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_MAX_PIXELSTOCONSIDER, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_SIGNAL_THRESHOLD, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_DARK_THRESHOLD, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_ENABLE_HISTOGRAM, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_ENABLE_CONTRAST, new PoolEntry<uint8_t>({0}));
localDataPoolMap.emplace(StarTracker::BLOB_BIN_MODE, new PoolEntry<uint8_t>({0}));
return RETURN_OK;
}
@ -1136,12 +1115,12 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* fo
*foundId = StarTracker::MOUNTING;
break;
}
case (StarTracker::ID::CAMERA): {
*foundId = StarTracker::CAMERA;
case (StarTracker::ID::IMAGE_PROCESSOR): {
*foundId = StarTracker::IMAGE_PROCESSOR;
break;
}
case (StarTracker::ID::BLOB): {
*foundId = StarTracker::BLOB;
case (StarTracker::ID::CAMERA): {
*foundId = StarTracker::CAMERA;
break;
}
case (StarTracker::ID::CENTROIDING): {
@ -1187,10 +1166,6 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* fo
*foundId = StarTracker::REQ_LIMITS;
break;
}
case (StarTracker::ID::BLOB): {
*foundId = StarTracker::REQ_BLOB_PARAMS;
break;
}
default: {
sif::warning << "tarTrackerHandler::scanForGetParameterReply: UnkNown ID" << std::endl;
return RETURN_FAILED;
@ -1236,8 +1211,8 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
break;
}
default: {
sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id"
<< std::endl;
sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id: "
<< static_cast<unsigned int>(*reply) << std::endl;
return RETURN_FAILED;
break;
}
@ -1730,9 +1705,6 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
result = paramSet.create(fullName, commandBuffer);
if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareParamCommand: Failed to create parameter "
"command"
<< std::endl;
return result;
}
dataLinkLayer.encodeFrame(commandBuffer, paramSet.getSize());
@ -1826,15 +1798,6 @@ ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() {
return RETURN_OK;
}
ReturnValue_t StarTrackerHandler::prepareRequestBlobParams() {
uint32_t length = 0;
arc_pack_blob_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);
@ -2065,15 +2028,14 @@ void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
break;
}
case (StarTracker::ID::MOUNTING): {
startupState = StartupState::IMAGE_PROCESSOR;
break;
}
case (StarTracker::ID::IMAGE_PROCESSOR): {
startupState = StartupState::CAMERA;
break;
}
case (StarTracker::ID::CAMERA): {
// startupState = StartupState::BLOB;
startupState = StartupState::CENTROIDING;
break;
}
case (StarTracker::ID::BLOB): {
startupState = StartupState::CENTROIDING;
break;
}

23
bsp_q7s/devices/startracker/StarTrackerHandler.h
View File

@ -72,15 +72,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
private:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HANDLER;
//! [EXPORT] : [COMMENT] Received reply is too short
static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB0);
//! [EXPORT] : [COMMENT] Received reply with invalid CRC
static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB1);
//! [EXPORT] : [COMMENT] Image loader executing
static const ReturnValue_t IMAGE_LOADER_EXECUTING = MAKE_RETURN_CODE(0xB2);
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HANDLER;
//! [EXPORT] : [COMMENT] Status in temperature reply signals error
static const ReturnValue_t TEMPERATURE_REQ_FAILED = MAKE_RETURN_CODE(0xA0);
//! [EXPORT] : [COMMENT] Ping command failed
@ -132,6 +123,13 @@ class StarTrackerHandler : public DeviceHandlerBase {
static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6);
//! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID
static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB7);
//! [EXPORT] : [COMMENT] Received reply is too short
static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB8);
//! [EXPORT] : [COMMENT] Received reply with invalid CRC
static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB9);
//! [EXPORT] : [COMMENT] Star tracker handler currently executing a command and using the
//! communication interface
static const ReturnValue_t STR_HELPER_EXECUTING = MAKE_RETURN_CODE(0xBA);
static const size_t MAX_PATH_SIZE = 50;
static const size_t MAX_FILE_NAME = 30;
@ -262,7 +260,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
StarTracker::DownloadBlobPixel downloadBlobPixel;
StarTracker::CameraSet cameraSet;
StarTracker::LimitsSet limitsSet;
StarTracker::BlobSet blobSet;
// Pointer to object responsible for uploading and downloading images to/from the star tracker
StrHelper* strHelper = nullptr;
@ -286,6 +283,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
LIMITS,
TRACKING,
MOUNTING,
IMAGE_PROCESSOR,
CAMERA,
BLOB,
CENTROIDING,
@ -502,11 +500,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
*/
ReturnValue_t prepareRequestLimitsParams();
/**
* @brief Will fill the command buffer with the command to request the set blob parameters.
*/
ReturnValue_t prepareRequestBlobParams();
/**
* @brief Handles action replies with datasets.
*/

42
bsp_q7s/devices/startracker/StarTrackerJsonCommands.cpp
View File

@ -152,6 +152,48 @@ ReturnValue_t Mounting::createCommand(uint8_t* buffer) {
return RETURN_OK;
}
ImageProcessor::ImageProcessor() : ArcsecJsonParamBase(arcseckeys::IMAGE_PROCESSOR) {}
size_t ImageProcessor::getSize() { return COMMAND_SIZE; }
ReturnValue_t ImageProcessor::createCommand(uint8_t* buffer) {
ReturnValue_t result = RETURN_OK;
uint8_t offset = 0;
std::string param;
addSetParamHeader(buffer, StarTracker::ID::IMAGE_PROCESSOR);
offset = 2;
result = getParam(arcseckeys::IMAGE_PROCESSOR_MODE, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::STORE, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::SIGNAL_THRESHOLD, param);
if (result != RETURN_OK) {
return result;
}
adduint16(param, buffer + offset);
offset += sizeof(uint16_t);
result = getParam(arcseckeys::IMAGE_PROCESSOR_DARK_THRESHOLD, param);
if (result != RETURN_OK) {
return result;
}
adduint16(param, buffer + offset);
offset += sizeof(uint16_t);
result = getParam(arcseckeys::BACKGROUND_COMPENSATION, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
return RETURN_OK;
}
Camera::Camera() : ArcsecJsonParamBase(arcseckeys::CAMERA) {}
size_t Camera::getSize() { return COMMAND_SIZE; }

16
bsp_q7s/devices/startracker/StarTrackerJsonCommands.h
View File

@ -60,6 +60,22 @@ class Mounting : public ArcsecJsonParamBase {
ReturnValue_t createCommand(uint8_t* buffer) override;
};
/**
* @brief Generates the command to configure the image processor
*
*/
class ImageProcessor : public ArcsecJsonParamBase {
public:
ImageProcessor();
size_t getSize();
private:
static const size_t COMMAND_SIZE = 9;
ReturnValue_t createCommand(uint8_t* buffer) override;
};
/**
* @brief Generates the command to set the mounting quaternion
*

2
fsfw

@ -1 +1 @@
Subproject commit cc7a3a5a342aa274ba85805ebdfef65224bbe80c
Subproject commit faf7da2743dcd30d83c3ab2f7b4d85277878e636

2
linux/obc/PtmeRateSetter.cpp
View File

@ -16,7 +16,7 @@ ReturnValue_t PtmeRateSetter::initialize() {
}
ReturnValue_t PtmeRateSetter::setRate(uint32_t bitRate) {
if (bitRate == 0) {
if (bitRate <= 1) {
return BAD_BIT_RATE;
}
uint32_t rateVal = PtmeConfig::BIT_CLK_FREQ / bitRate - 1;

2
tmtc

@ -1 +1 @@
Subproject commit b06211d0865f5d904572635340303d8b4aec30eb
Subproject commit 598635ee4fb1eb246980564ae9f3a0feb1f4da30