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 qy[] = "qy";
static const char qz[] = "qz"; 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 CAMERA[] = "camera";
static const char MODE[] = "mode"; static const char MODE[] = "mode";
static const char FOCALLENGTH[] = "focallength"; 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 MIN_BRIGHT_NEIGHBOURS[] = "minBrightNeighbours";
static const char MAX_BRIGHT_NEIGHBOURS[] = "maxBrightNeighbours"; static const char MAX_BRIGHT_NEIGHBOURS[] = "maxBrightNeighbours";
static const char MAX_PIXEL_TO_CONSIDER[] = "maxPixelsToConsider"; 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 BLOB_DARK_THRESHOLD[] = "darkThreshold";
static const char ENABLE_HISTOGRAM[] = "enableHistogram"; static const char ENABLE_HISTOGRAM[] = "enableHistogram";
static const char ENABLE_CONTRAST[] = "enableContrast"; 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; return RETURN_OK;
} }
} }
sif::warning << "ArcsecJsonParamBase::initSet: Set " << setName << "not present in json file"
<< std::endl;
return SET_NOT_EXISTS; 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, TIME_TEMPERATURE_SET,
MCU_TEMPERATURE, MCU_TEMPERATURE,
CMOS_TEMPERATURE, CMOS_TEMPERATURE,
FPGA_TEMPERATURE,
TICKS_SOLUTION_SET, TICKS_SOLUTION_SET,
TIME_SOLUTION_SET, TIME_SOLUTION_SET,
CALI_QW, CALI_QW,
@ -257,6 +258,7 @@ static const DeviceCommandId_t TAKE_IMAGE = 15;
static const DeviceCommandId_t DOWNLOAD_CENTROID = 16; static const DeviceCommandId_t DOWNLOAD_CENTROID = 16;
static const DeviceCommandId_t UPLOAD_CENTROID = 17; static const DeviceCommandId_t UPLOAD_CENTROID = 17;
static const DeviceCommandId_t SUBSCRIBE_TO_TM = 18; 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_SOLUTION = 24;
static const DeviceCommandId_t REQ_TEMPERATURE = 25; static const DeviceCommandId_t REQ_TEMPERATURE = 25;
static const DeviceCommandId_t REQ_HISTOGRAM = 28; 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 LIMITS = 40;
static const DeviceCommandId_t MOUNTING = 41; static const DeviceCommandId_t MOUNTING = 41;
static const DeviceCommandId_t CAMERA = 42; static const DeviceCommandId_t CAMERA = 42;
static const DeviceCommandId_t BLOB = 43;
static const DeviceCommandId_t CENTROIDING = 44; static const DeviceCommandId_t CENTROIDING = 44;
static const DeviceCommandId_t LISA = 45; static const DeviceCommandId_t LISA = 45;
static const DeviceCommandId_t MATCHING = 46; 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 FPGA_ACTION = 66;
static const DeviceCommandId_t REQ_CAMERA = 67; static const DeviceCommandId_t REQ_CAMERA = 67;
static const DeviceCommandId_t REQ_LIMITS = 68; static const DeviceCommandId_t REQ_LIMITS = 68;
static const DeviceCommandId_t REQ_BLOB_PARAMS = 69;
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;
@ -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 DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL;
static const uint32_t CAMERA_SET_ID = REQ_CAMERA; static const uint32_t CAMERA_SET_ID = REQ_CAMERA;
static const uint32_t LIMITS_SET_ID = REQ_LIMITS; static const uint32_t LIMITS_SET_ID = REQ_LIMITS;
static const uint32_t BLOB_SET_ID = REQ_BLOB_PARAMS;
/** Max size of unencoded frame */ /** Max size of unencoded frame */
static const size_t MAX_FRAME_SIZE = 1200; 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 VERSION_SET_ENTRIES = 5;
static const uint8_t INTERFACE_SET_ENTRIES = 4; static const uint8_t INTERFACE_SET_ENTRIES = 4;
static const uint8_t POWER_SET_ENTRIES = 18; 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 DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7;
static const uint8_t CAMERA_SET_ENTRIES = 15; static const uint8_t CAMERA_SET_ENTRIES = 15;
static const uint8_t LIMITS_SET_ENTRIES = 11; static const uint8_t LIMITS_SET_ENTRIES = 11;
static const uint8_t BLOB_SET_ENTRIES = 15;
// Action, parameter and telemetry IDs // Action, parameter and telemetry IDs
namespace ID { namespace ID {
@ -337,8 +335,8 @@ static const uint8_t VERSION = 2;
static const uint8_t INTERFACE = 3; static const uint8_t INTERFACE = 3;
static const uint8_t LIMITS = 5; static const uint8_t LIMITS = 5;
static const uint8_t MOUNTING = 6; static const uint8_t MOUNTING = 6;
static const uint8_t IMAGE_PROCESSOR = 10;
static const uint8_t CAMERA = 9; static const uint8_t CAMERA = 9;
static const uint8_t BLOB = 10;
static const uint8_t CENTROIDING = 11; static const uint8_t CENTROIDING = 11;
static const uint8_t LISA = 12; static const uint8_t LISA = 12;
static const uint8_t MATCHING = 13; 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 SET_TIME = 14;
static const uint8_t SUBSCRIBE = 18; static const uint8_t SUBSCRIBE = 18;
static const uint8_t SOLUTION = 24; 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 HISTOGRAM = 28;
static const uint8_t CONTRAST = 29; static const uint8_t CONTRAST = 29;
static const uint8_t TIME = 1; static const uint8_t TIME = 1;
@ -380,7 +378,7 @@ static const uint8_t FIRMWARE = 2;
*/ */
class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> { class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
public: public:
static const size_t SIZE = 20; static const size_t SIZE = 24;
TemperatureSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEMPERATURE_SET_ID) {} 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<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> 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> 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() { void printSet() {
sif::info << "TemperatureSet::printSet: Ticks: " << this->ticks << std::endl; sif::info << "TemperatureSet::printSet: Ticks: " << this->ticks << std::endl;
sif::info << "TemperatureSet::printSet: Time: " << this->time << " us" << std::endl; sif::info << "TemperatureSet::printSet: Time: " << this->time << " us" << std::endl;
sif::info << "TemperatureSet::printSet: MCU Temperature: " << this->mcuTemperature << " °C" sif::info << "TemperatureSet::printSet: MCU Temperature: " << this->mcuTemperature << " °C"
<< std::endl; << std::endl;
sif::info << "TemperatureSet::printSet: CMOS Temperature: " << this->cmosTemperature << " °C" sif::info << "TemperatureSet::printSet: CMOS Temperature (raw): " << this->cmosTemperature
<< std::endl; << 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; 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 } // namespace StarTracker
#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */ #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/actionreq.h>
#include <thirdparty/arcsec_star_tracker/client/generated/parameter.h> #include <thirdparty/arcsec_star_tracker/client/generated/parameter.h>
#include <thirdparty/arcsec_star_tracker/client/generated/telemetry.h> #include <thirdparty/arcsec_star_tracker/client/generated/telemetry.h>
#include "common/misc.h" #include "common/misc.h"
} }
@ -109,7 +108,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
} }
if (strHelperExecuting == true) { if (strHelperExecuting == true) {
return IMAGE_LOADER_EXECUTING; return STR_HELPER_EXECUTING;
} }
result = checkMode(actionId); result = checkMode(actionId);
@ -316,16 +315,16 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
*id = StarTracker::MOUNTING; *id = StarTracker::MOUNTING;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size()); 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: case StartupState::CAMERA:
startupState = StartupState::WAIT_FOR_EXECUTION; startupState = StartupState::WAIT_FOR_EXECUTION;
*id = StarTracker::CAMERA; *id = StarTracker::CAMERA;
return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), return buildCommandFromCommand(*id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()),
paramJsonFile.size()); 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: case StartupState::CENTROIDING:
startupState = StartupState::WAIT_FOR_EXECUTION; startupState = StartupState::WAIT_FOR_EXECUTION;
*id = StarTracker::CENTROIDING; *id = StarTracker::CENTROIDING;
@ -428,16 +427,16 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
result = prepareParamCommand(commandData, commandDataLen, mounting); result = prepareParamCommand(commandData, commandDataLen, mounting);
return result; return result;
} }
case (StarTracker::IMAGE_PROCESSOR): {
ImageProcessor imageProcessor;
result = prepareParamCommand(commandData, commandDataLen, imageProcessor);
return result;
}
case (StarTracker::CAMERA): { case (StarTracker::CAMERA): {
Camera camera; Camera camera;
result = prepareParamCommand(commandData, commandDataLen, camera); result = prepareParamCommand(commandData, commandDataLen, camera);
return result; return result;
} }
case (StarTracker::BLOB): {
Blob blob;
result = prepareParamCommand(commandData, commandDataLen, blob);
return result;
}
case (StarTracker::CENTROIDING): { case (StarTracker::CENTROIDING): {
Centroiding centroiding; Centroiding centroiding;
result = prepareParamCommand(commandData, commandDataLen, centroiding); result = prepareParamCommand(commandData, commandDataLen, centroiding);
@ -558,9 +557,9 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
StarTracker::MAX_FRAME_SIZE * 2 + 2); StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::MOUNTING, 3, nullptr, this->insertInCommandAndReplyMap(StarTracker::MOUNTING, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2); 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); StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::BLOB, 3, nullptr, this->insertInCommandAndReplyMap(StarTracker::CAMERA, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2); StarTracker::MAX_FRAME_SIZE * 2 + 2);
this->insertInCommandAndReplyMap(StarTracker::CENTROIDING, 3, nullptr, this->insertInCommandAndReplyMap(StarTracker::CENTROIDING, 3, nullptr,
StarTracker::MAX_FRAME_SIZE * 2 + 2); StarTracker::MAX_FRAME_SIZE * 2 + 2);
@ -751,12 +750,12 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
case (StarTracker::LIMITS): case (StarTracker::LIMITS):
case (StarTracker::MOUNTING): case (StarTracker::MOUNTING):
case (StarTracker::CAMERA): case (StarTracker::CAMERA):
case (StarTracker::BLOB):
case (StarTracker::CENTROIDING): case (StarTracker::CENTROIDING):
case (StarTracker::LISA): case (StarTracker::LISA):
case (StarTracker::MATCHING): case (StarTracker::MATCHING):
case (StarTracker::TRACKING): case (StarTracker::TRACKING):
case (StarTracker::VALIDATION): case (StarTracker::VALIDATION):
case (StarTracker::IMAGE_PROCESSOR):
case (StarTracker::ALGO): { case (StarTracker::ALGO): {
result = handleSetParamReply(); result = handleSetParamReply();
break; break;
@ -769,10 +768,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE); handleParamRequest(limitsSet, StarTracker::LimitsSet::SIZE);
break; break;
} }
case (StarTracker::REQ_BLOB_PARAMS): {
handleParamRequest(blobSet, StarTracker::BlobSet::SIZE);
break;
}
default: { default: {
sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id sif::debug << "StarTrackerHandler::interpretDeviceReply: Unknown device reply id:" << id
<< std::endl; << 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::TIME_TEMPERATURE_SET, new PoolEntry<uint64_t>({0}));
localDataPoolMap.emplace(StarTracker::MCU_TEMPERATURE, new PoolEntry<float>({0})); localDataPoolMap.emplace(StarTracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::CMOS_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::TICKS_SOLUTION_SET, new PoolEntry<uint32_t>({0}));
localDataPoolMap.emplace(StarTracker::TIME_SOLUTION_SET, new PoolEntry<uint64_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_CMOS33CURRENT, new PoolEntry<float>({0}));
localDataPoolMap.emplace(StarTracker::LIMITS_CMOSVRESCURRENT, 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::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; return RETURN_OK;
} }
@ -1136,12 +1115,12 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* fo
*foundId = StarTracker::MOUNTING; *foundId = StarTracker::MOUNTING;
break; break;
} }
case (StarTracker::ID::CAMERA): { case (StarTracker::ID::IMAGE_PROCESSOR): {
*foundId = StarTracker::CAMERA; *foundId = StarTracker::IMAGE_PROCESSOR;
break; break;
} }
case (StarTracker::ID::BLOB): { case (StarTracker::ID::CAMERA): {
*foundId = StarTracker::BLOB; *foundId = StarTracker::CAMERA;
break; break;
} }
case (StarTracker::ID::CENTROIDING): { case (StarTracker::ID::CENTROIDING): {
@ -1187,10 +1166,6 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* fo
*foundId = StarTracker::REQ_LIMITS; *foundId = StarTracker::REQ_LIMITS;
break; break;
} }
case (StarTracker::ID::BLOB): {
*foundId = StarTracker::REQ_BLOB_PARAMS;
break;
}
default: { default: {
sif::warning << "tarTrackerHandler::scanForGetParameterReply: UnkNown ID" << std::endl; sif::warning << "tarTrackerHandler::scanForGetParameterReply: UnkNown ID" << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
@ -1236,8 +1211,8 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(DeviceCommandId_t* foundId) {
break; break;
} }
default: { default: {
sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id" sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id: "
<< std::endl; << static_cast<unsigned int>(*reply) << std::endl;
return RETURN_FAILED; return RETURN_FAILED;
break; break;
} }
@ -1730,9 +1705,6 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
result = paramSet.create(fullName, commandBuffer); result = paramSet.create(fullName, commandBuffer);
if (result != RETURN_OK) { if (result != RETURN_OK) {
sif::warning << "StarTrackerHandler::prepareParamCommand: Failed to create parameter "
"command"
<< std::endl;
return result; return result;
} }
dataLinkLayer.encodeFrame(commandBuffer, paramSet.getSize()); dataLinkLayer.encodeFrame(commandBuffer, paramSet.getSize());
@ -1826,15 +1798,6 @@ ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() {
return RETURN_OK; 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() { ReturnValue_t StarTrackerHandler::handleSetParamReply() {
const uint8_t* reply = dataLinkLayer.getReply(); const uint8_t* reply = dataLinkLayer.getReply();
uint8_t status = *(reply + STATUS_OFFSET); uint8_t status = *(reply + STATUS_OFFSET);
@ -2065,15 +2028,14 @@ void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
break; break;
} }
case (StarTracker::ID::MOUNTING): { case (StarTracker::ID::MOUNTING): {
startupState = StartupState::IMAGE_PROCESSOR;
break;
}
case (StarTracker::ID::IMAGE_PROCESSOR): {
startupState = StartupState::CAMERA; startupState = StartupState::CAMERA;
break; break;
} }
case (StarTracker::ID::CAMERA): { case (StarTracker::ID::CAMERA): {
// startupState = StartupState::BLOB;
startupState = StartupState::CENTROIDING;
break;
}
case (StarTracker::ID::BLOB): {
startupState = StartupState::CENTROIDING; startupState = StartupState::CENTROIDING;
break; break;
} }

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

@ -72,15 +72,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
private: private:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HANDLER; 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 //! [EXPORT] : [COMMENT] Status in temperature reply signals error
static const ReturnValue_t TEMPERATURE_REQ_FAILED = MAKE_RETURN_CODE(0xA0); static const ReturnValue_t TEMPERATURE_REQ_FAILED = MAKE_RETURN_CODE(0xA0);
//! [EXPORT] : [COMMENT] Ping command failed //! [EXPORT] : [COMMENT] Ping command failed
@ -132,6 +123,13 @@ class StarTrackerHandler : public DeviceHandlerBase {
static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6); static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6);
//! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID //! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID
static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB7); 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_PATH_SIZE = 50;
static const size_t MAX_FILE_NAME = 30; static const size_t MAX_FILE_NAME = 30;
@ -262,7 +260,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
StarTracker::DownloadBlobPixel downloadBlobPixel; StarTracker::DownloadBlobPixel downloadBlobPixel;
StarTracker::CameraSet cameraSet; StarTracker::CameraSet cameraSet;
StarTracker::LimitsSet limitsSet; StarTracker::LimitsSet limitsSet;
StarTracker::BlobSet blobSet;
// Pointer to object responsible for uploading and downloading images to/from the star tracker // Pointer to object responsible for uploading and downloading images to/from the star tracker
StrHelper* strHelper = nullptr; StrHelper* strHelper = nullptr;
@ -286,6 +283,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
LIMITS, LIMITS,
TRACKING, TRACKING,
MOUNTING, MOUNTING,
IMAGE_PROCESSOR,
CAMERA, CAMERA,
BLOB, BLOB,
CENTROIDING, CENTROIDING,
@ -502,11 +500,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
*/ */
ReturnValue_t prepareRequestLimitsParams(); 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. * @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; 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) {} Camera::Camera() : ArcsecJsonParamBase(arcseckeys::CAMERA) {}
size_t Camera::getSize() { return COMMAND_SIZE; } 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; 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 * @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) { ReturnValue_t PtmeRateSetter::setRate(uint32_t bitRate) {
if (bitRate == 0) { if (bitRate <= 1) {
return BAD_BIT_RATE; return BAD_BIT_RATE;
} }
uint32_t rateVal = PtmeConfig::BIT_CLK_FREQ / bitRate - 1; uint32_t rateVal = PtmeConfig::BIT_CLK_FREQ / bitRate - 1;

2
tmtc

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