meier/startracker #155
@ -214,6 +214,15 @@ enum PoolIds : lp_id_t {
|
||||
CAM_VAL3,
|
||||
CAM_REG4,
|
||||
CAM_VAL4,
|
||||
CAM_REG5,
|
||||
CAM_VAL5,
|
||||
CAM_REG6,
|
||||
CAM_VAL6,
|
||||
CAM_REG7,
|
||||
CAM_VAL7,
|
||||
CAM_REG8,
|
||||
CAM_VAL8,
|
||||
CAM_FREQ_1,
|
||||
LIMITS_ACTION,
|
||||
LIMITS_FPGA18CURRENT,
|
||||
LIMITS_FPGA25CURRENT,
|
||||
@ -239,7 +248,96 @@ enum PoolIds : lp_id_t {
|
||||
BLOB_DARK_THRESHOLD,
|
||||
BLOB_ENABLE_HISTOGRAM,
|
||||
BLOB_ENABLE_CONTRAST,
|
||||
BLOB_BIN_MODE
|
||||
BLOB_BIN_MODE,
|
||||
LOGLEVEL1,
|
||||
LOGLEVEL2,
|
||||
LOGLEVEL3,
|
||||
LOGLEVEL4,
|
||||
LOGLEVEL5,
|
||||
LOGLEVEL6,
|
||||
LOGLEVEL7,
|
||||
LOGLEVEL8,
|
||||
LOGLEVEL9,
|
||||
LOGLEVEL10,
|
||||
LOGLEVEL11,
|
||||
LOGLEVEL12,
|
||||
LOGLEVEL13,
|
||||
LOGLEVEL14,
|
||||
LOGLEVEL15,
|
||||
LOGLEVEL16,
|
||||
MOUNTING_QW,
|
||||
MOUNTING_QX,
|
||||
MOUNTING_QY,
|
||||
MOUNTING_QZ,
|
||||
IMAGE_PROCESSOR_MODE,
|
||||
IMAGE_PROCESSOR_STORE,
|
||||
IMAGE_PROCESSOR_SIGNALTHRESHOLD,
|
||||
IMAGE_PROCESSOR_DARKTHRESHOLD,
|
||||
IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION,
|
||||
CENTROIDING_ENABLE_FILTER,
|
||||
CENTROIDING_MAX_QUALITY,
|
||||
CENTROIDING_DARK_THRESHOLD,
|
||||
CENTROIDING_MIN_QUALITY,
|
||||
CENTROIDING_MAX_INTENSITY,
|
||||
CENTROIDING_MIN_INTENSITY,
|
||||
CENTROIDING_MAX_MAGNITUDE,
|
||||
CENTROIDING_GAUSSIAN_CMAX,
|
||||
CENTROIDING_GAUSSIAN_CMIN,
|
||||
CENTROIDING_TRANSMATRIX00,
|
||||
CENTROIDING_TRANSMATRIX01,
|
||||
CENTROIDING_TRANSMATRIX10,
|
||||
CENTROIDING_TRANSMATRIX11,
|
||||
LISA_MODE,
|
||||
LISA_PREFILTER_DIST_THRESHOLD,
|
||||
LISA_PREFILTER_ANGLE_THRESHOLD,
|
||||
LISA_FOV_WIDTH,
|
||||
LISA_FOV_HEIGHT,
|
||||
LISA_FLOAT_STAR_LIMIT,
|
||||
LISA_CLOSE_STAR_LIMIT,
|
||||
LISA_RATING_WEIGHT_CLOSE_STAR_COUNT,
|
||||
LISA_RATING_WEIGHT_FRACTION_CLOSE,
|
||||
LISA_RATING_WEIGHT_MEAN_SUM,
|
||||
LISA_RATING_WEIGHT_DB_STAR_COUNT,
|
||||
LISA_MAX_COMBINATIONS,
|
||||
LISA_NR_STARS_STOP,
|
||||
LISA_FRACTION_CLOSE_STOP,
|
||||
MATCHING_SQUARED_DISTANCE_LIMIT,
|
||||
MATCHING_SQUARED_SHIFT_LIMIT,
|
||||
TRACKING_THIN_LIMIT,
|
||||
TRACKING_OUTLIER_THRESHOLD,
|
||||
TRACKING_OUTLIER_THRESHOLD_QUEST,
|
||||
TRACKING_TRACKER_CHOICE,
|
||||
VALIDATION_STABLE_COUNT,
|
||||
VALIDATION_MAX_DIFFERENCE,
|
||||
VALIDATION_MIN_TRACKER_CONFIDENCE,
|
||||
VALIDATION_MIN_MATCHED_STARS,
|
||||
ALGO_MODE,
|
||||
ALGO_I2T_MIN_CONFIDENCE,
|
||||
ALGO_I2T_MIN_MATCHED,
|
||||
ALGO_I2L_MIN_CONFIDENCE,
|
||||
ALGO_I2L_MIN_MATCHED,
|
||||
SUBSCRIPTION_TM1,
|
||||
SUBSCRIPTION_TM2,
|
||||
SUBSCRIPTION_TM3,
|
||||
SUBSCRIPTION_TM4,
|
||||
SUBSCRIPTION_TM5,
|
||||
SUBSCRIPTION_TM6,
|
||||
SUBSCRIPTION_TM7,
|
||||
SUBSCRIPTION_TM8,
|
||||
SUBSCRIPTION_TM9,
|
||||
SUBSCRIPTION_TM10,
|
||||
SUBSCRIPTION_TM11,
|
||||
SUBSCRIPTION_TM12,
|
||||
SUBSCRIPTION_TM13,
|
||||
SUBSCRIPTION_TM14,
|
||||
SUBSCRIPTION_TM15,
|
||||
SUBSCRIPTION_TM16,
|
||||
LOG_SUBSCRIPTION_LEVEL1,
|
||||
LOG_SUBSCRIPTION_MODULE1,
|
||||
LOG_SUBSCRIPTION_LEVEL2,
|
||||
LOG_SUBSCRIPTION_MODULE2,
|
||||
DEBUG_CAMERA_TIMING,
|
||||
DEBUG_CAMERA_TEST
|
||||
};
|
||||
|
||||
static const DeviceCommandId_t PING_REQUEST = 0;
|
||||
@ -290,6 +388,18 @@ 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_LOG_LEVEL = 69;
|
||||
static const DeviceCommandId_t REQ_MOUNTING = 70;
|
||||
static const DeviceCommandId_t REQ_IMAGE_PROCESSOR = 71;
|
||||
static const DeviceCommandId_t REQ_CENTROIDING = 72;
|
||||
static const DeviceCommandId_t REQ_LISA = 73;
|
||||
static const DeviceCommandId_t REQ_MATCHING = 74;
|
||||
static const DeviceCommandId_t REQ_TRACKING = 75;
|
||||
static const DeviceCommandId_t REQ_VALIDATION = 76;
|
||||
static const DeviceCommandId_t REQ_ALGO = 77;
|
||||
static const DeviceCommandId_t REQ_SUBSCRIPTION = 78;
|
||||
static const DeviceCommandId_t REQ_LOG_SUBSCRIPTION = 79;
|
||||
static const DeviceCommandId_t REQ_DEBUG_CAMERA = 80;
|
||||
static const DeviceCommandId_t NONE = 0xFFFFFFFF;
|
||||
|
||||
static const uint32_t VERSION_SET_ID = REQ_VERSION;
|
||||
@ -307,6 +417,17 @@ 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 LOG_LEVEL_SET_ID = REQ_LOG_LEVEL;
|
||||
static const uint32_t MOUNTING_SET_ID = REQ_MOUNTING;
|
||||
static const uint32_t IMAGE_PROCESSOR_SET_ID = REQ_IMAGE_PROCESSOR;
|
||||
static const uint32_t CENTROIDING_SET_ID = REQ_CENTROIDING;
|
||||
static const uint32_t LISA_SET_ID = REQ_LISA;
|
||||
static const uint32_t MATCHING_SET_ID = REQ_MATCHING;
|
||||
static const uint32_t TRACKING_SET_ID = REQ_TRACKING;
|
||||
static const uint32_t VALIDATION_SET_ID = REQ_VALIDATION;
|
||||
static const uint32_t ALGO_SET_ID = REQ_ALGO;
|
||||
static const uint32_t SUBSCRIPTION_SET_ID = REQ_SUBSCRIPTION;
|
||||
static const uint32_t LOG_SUBSCRIPTION_SET_ID = REQ_LOG_SUBSCRIPTION;
|
||||
|
||||
/** Max size of unencoded frame */
|
||||
static const size_t MAX_FRAME_SIZE = 1200;
|
||||
@ -324,8 +445,20 @@ static const uint8_t DOWNLOAD_CENTROID_SET_ENTRIES = 11;
|
||||
static const uint8_t DOWNLOAD_MATCHED_STAR_SET_ENTRIES = 14;
|
||||
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 CAMERA_SET_ENTRIES = 24;
|
||||
static const uint8_t LIMITS_SET_ENTRIES = 11;
|
||||
static const uint8_t LOG_LEVEL_SET_ENTRIES = 16;
|
||||
static const uint8_t MOUNTING_SET_ENTRIES = 4;
|
||||
static const uint8_t IMAGE_PROCESSOR_SET_ENTRIES = 5;
|
||||
static const uint8_t CENTROIDING_PARAMS_SET_ENTRIES = 13;
|
||||
static const uint8_t LISA_SET_ENTRIES = 14;
|
||||
static const uint8_t MATCHING_SET_ENTRIES = 2;
|
||||
static const uint8_t TRACKING_SET_ENTRIES = 4;
|
||||
static const uint8_t VALIDATION_SET_ENTRIES = 4;
|
||||
static const uint8_t ALGO_SET_ENTRIES = 5;
|
||||
static const uint8_t SUBSCRIPTION_SET_ENTRIES = 16;
|
||||
static const uint8_t LOG_SUBSCRIPTION_SET_ENTRIES = 4;
|
||||
static const uint8_t DEBUG_CAMERA_SET_ENTRIES = 2;
|
||||
|
||||
// Action, parameter and telemetry IDs
|
||||
namespace ID {
|
||||
@ -347,7 +480,7 @@ static const uint8_t REBOOT = 7;
|
||||
static const uint8_t UPLOAD_IMAGE = 10;
|
||||
static const uint8_t POWER = 11;
|
||||
static const uint8_t SET_TIME = 14;
|
||||
static const uint8_t SUBSCRIBE = 18;
|
||||
static const uint8_t SUBSCRIPTION = 18;
|
||||
static const uint8_t SOLUTION = 24;
|
||||
static const uint8_t TEMPERATURE = 27;
|
||||
static const uint8_t HISTOGRAM = 28;
|
||||
@ -366,6 +499,9 @@ static const uint8_t DOWNLOAD_MATCHED_STAR = 18;
|
||||
static const uint8_t DOWNLOAD_DBIMAGE = 19;
|
||||
static const uint8_t DOWNLOAD_BLOBPIXEL = 24;
|
||||
static const uint8_t FPGA_ACTION = 22;
|
||||
static const uint8_t LOG_LEVEL = 3;
|
||||
static const uint8_t LOG_SUBSCRIPTION = 19;
|
||||
static const uint8_t DEBUG_CAMERA = 20;
|
||||
} // namespace ID
|
||||
|
||||
namespace Program {
|
||||
@ -1103,7 +1239,7 @@ class DownloadBlobPixel : public StaticLocalDataSet<DOWNLOAD_BLOBPIXEL_SET_ENTRI
|
||||
class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 25;
|
||||
static const size_t SIZE = 34;
|
||||
|
||||
CameraSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CAMERA_SET_ID) {}
|
||||
|
||||
@ -1124,6 +1260,15 @@ class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
|
||||
lp_var_t<uint8_t> val3 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL3, this);
|
||||
lp_var_t<uint8_t> reg4 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG4, this);
|
||||
lp_var_t<uint8_t> val4 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL4, this);
|
||||
lp_var_t<uint8_t> reg5 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG5, this);
|
||||
lp_var_t<uint8_t> val5 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL5, this);
|
||||
lp_var_t<uint8_t> reg6 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG6, this);
|
||||
lp_var_t<uint8_t> val6 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL6, this);
|
||||
lp_var_t<uint8_t> reg7 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG7, this);
|
||||
lp_var_t<uint8_t> val7 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL7, this);
|
||||
lp_var_t<uint8_t> reg8 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG8, this);
|
||||
lp_var_t<uint8_t> val8 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL8, this);
|
||||
lp_var_t<uint8_t> freq1 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_FREQ_1, this);
|
||||
|
||||
void printSet() {
|
||||
PoolReadGuard rg(this);
|
||||
@ -1153,6 +1298,24 @@ class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Val 4: " << static_cast<unsigned int>(this->val4.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Reg 5: " << static_cast<unsigned int>(this->reg5.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Val 5: " << static_cast<unsigned int>(this->val5.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Reg 6: " << static_cast<unsigned int>(this->reg6.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Val 6: " << static_cast<unsigned int>(this->val6.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Reg 7: " << static_cast<unsigned int>(this->reg7.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Val 7: " << static_cast<unsigned int>(this->val7.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Reg 8: " << static_cast<unsigned int>(this->reg8.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Val 8: " << static_cast<unsigned int>(this->val8.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: Freq 1: " << static_cast<unsigned int>(this->freq1.value)
|
||||
<< std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
@ -1189,17 +1352,503 @@ class LimitsSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
|
||||
|
||||
void printSet() {
|
||||
PoolReadGuard rg(this);
|
||||
sif::info << "CameraSet::printSet: action: " << static_cast<unsigned int>(this->action.value)
|
||||
sif::info << "LimitsSet::printSet: action: " << static_cast<unsigned int>(this->action.value)
|
||||
<< std::endl;
|
||||
sif::info << "CameraSet::printSet: FPGA18Current: " << this->fpga18current << std::endl;
|
||||
sif::info << "CameraSet::printSet: FPGA25Current: " << this->fpga25current << std::endl;
|
||||
sif::info << "CameraSet::printSet: FPGA10Current: " << this->fpga10current << std::endl;
|
||||
sif::info << "CameraSet::printSet: MCUCurrent: " << this->mcuCurrent << std::endl;
|
||||
sif::info << "CameraSet::printSet: CMOS21Current: " << this->cmos21current << std::endl;
|
||||
sif::info << "CameraSet::printSet: CMOSPixCurrent: " << this->cmosPixCurrent << std::endl;
|
||||
sif::info << "CameraSet::printSet: CMOS33Current: " << this->cmos33current << std::endl;
|
||||
sif::info << "CameraSet::printSet: CMOSVResCurrent: " << this->cmosVresCurrent << std::endl;
|
||||
sif::info << "CameraSet::printSet: CMOSTemperature: " << this->cmosTemperature << std::endl;
|
||||
sif::info << "LimitsSet::printSet: FPGA18Current: " << this->fpga18current << std::endl;
|
||||
sif::info << "LimitsSet::printSet: FPGA25Current: " << this->fpga25current << std::endl;
|
||||
sif::info << "LimitsSet::printSet: FPGA10Current: " << this->fpga10current << std::endl;
|
||||
sif::info << "LimitsSet::printSet: MCUCurrent: " << this->mcuCurrent << std::endl;
|
||||
sif::info << "LimitsSet::printSet: CMOS21Current: " << this->cmos21current << std::endl;
|
||||
sif::info << "LimitsSet::printSet: CMOSPixCurrent: " << this->cmosPixCurrent << std::endl;
|
||||
sif::info << "LimitsSet::printSet: CMOS33Current: " << this->cmos33current << std::endl;
|
||||
sif::info << "LimitsSet::printSet: CMOSVResCurrent: " << this->cmosVresCurrent << std::endl;
|
||||
sif::info << "LimitsSet::printSet: CMOSTemperature: " << this->cmosTemperature << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested log level parameters
|
||||
*/
|
||||
class LogLevelSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 16;
|
||||
|
||||
LogLevelSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOG_LEVEL_SET_ENTRIES) {}
|
||||
|
||||
LogLevelSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOG_LEVEL_SET_ENTRIES)) {}
|
||||
|
||||
lp_var_t<uint8_t> loglevel1 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL1, this);
|
||||
lp_var_t<uint8_t> loglevel2 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL2, this);
|
||||
lp_var_t<uint8_t> loglevel3 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL3, this);
|
||||
lp_var_t<uint8_t> loglevel4 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL4, this);
|
||||
lp_var_t<uint8_t> loglevel5 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL5, this);
|
||||
lp_var_t<uint8_t> loglevel6 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL6, this);
|
||||
lp_var_t<uint8_t> loglevel7 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL7, this);
|
||||
lp_var_t<uint8_t> loglevel8 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL8, this);
|
||||
lp_var_t<uint8_t> loglevel9 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL9, this);
|
||||
lp_var_t<uint8_t> loglevel10 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL10, this);
|
||||
lp_var_t<uint8_t> loglevel11 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL11, this);
|
||||
lp_var_t<uint8_t> loglevel12 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL12, this);
|
||||
lp_var_t<uint8_t> loglevel13 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL13, this);
|
||||
lp_var_t<uint8_t> loglevel14 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL14, this);
|
||||
lp_var_t<uint8_t> loglevel15 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL15, this);
|
||||
lp_var_t<uint8_t> loglevel16 = lp_var_t<uint8_t>(sid.objectId, PoolIds::LOGLEVEL16, this);
|
||||
|
||||
void printSet() {
|
||||
PoolReadGuard rg(this);
|
||||
sif::info << "LogLevelSet::printSet: loglevel1: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel2: "
|
||||
<< static_cast<unsigned int>(this->loglevel2.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel3: "
|
||||
<< static_cast<unsigned int>(this->loglevel3.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel4: "
|
||||
<< static_cast<unsigned int>(this->loglevel4.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel5: "
|
||||
<< static_cast<unsigned int>(this->loglevel5.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel6: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel7: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel8: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel9: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel10: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel11: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel12: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel13: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel14: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel15: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
sif::info << "LogLevelSet::printSet: loglevel16: "
|
||||
<< static_cast<unsigned int>(this->loglevel1.value) << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested mounting parameters
|
||||
*/
|
||||
class MountingSet : public StaticLocalDataSet<MOUNTING_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 16;
|
||||
|
||||
MountingSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, MOUNTING_SET_ID) {}
|
||||
|
||||
MountingSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, MOUNTING_SET_ID)) {}
|
||||
|
||||
lp_var_t<float> qw = lp_var_t<float>(sid.objectId, PoolIds::MOUNTING_QW, this);
|
||||
lp_var_t<float> qx = lp_var_t<float>(sid.objectId, PoolIds::MOUNTING_QX, this);
|
||||
lp_var_t<float> qy = lp_var_t<float>(sid.objectId, PoolIds::MOUNTING_QY, this);
|
||||
lp_var_t<float> qz = lp_var_t<float>(sid.objectId, PoolIds::MOUNTING_QZ, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "MountingSet::printSet: qw: " << this->qw << std::endl;
|
||||
sif::info << "MountingSet::printSet: qx: " << this->qx << std::endl;
|
||||
sif::info << "MountingSet::printSet: qy: " << this->qy << std::endl;
|
||||
sif::info << "MountingSet::printSet: qz: " << this->qz << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested image processor parameters
|
||||
*/
|
||||
class ImageProcessorSet : public StaticLocalDataSet<IMAGE_PROCESSOR_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 7;
|
||||
|
||||
ImageProcessorSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMAGE_PROCESSOR_SET_ID) {}
|
||||
|
||||
ImageProcessorSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMAGE_PROCESSOR_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, PoolIds::IMAGE_PROCESSOR_MODE, this);
|
||||
lp_var_t<uint8_t> store = lp_var_t<uint8_t>(sid.objectId, PoolIds::IMAGE_PROCESSOR_STORE, this);
|
||||
lp_var_t<uint16_t> signalThreshold =
|
||||
lp_var_t<uint16_t>(sid.objectId, PoolIds::IMAGE_PROCESSOR_SIGNALTHRESHOLD, this);
|
||||
lp_var_t<uint16_t> darkThreshold =
|
||||
lp_var_t<uint16_t>(sid.objectId, PoolIds::IMAGE_PROCESSOR_DARKTHRESHOLD, this);
|
||||
lp_var_t<uint8_t> backgroundCompensation =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "ImageProcessorSet::printSet: mode: " << this->mode << std::endl;
|
||||
sif::info << "ImageProcessorSet::printSet: store: " << this->store << std::endl;
|
||||
sif::info << "ImageProcessorSet::printSet: signal threshold: " << this->signalThreshold
|
||||
<< std::endl;
|
||||
sif::info << "ImageProcessorSet::printSet: dark threshold: " << this->darkThreshold
|
||||
<< std::endl;
|
||||
sif::info << "ImageProcessorSet::printSet: background compensation: "
|
||||
<< this->backgroundCompensation << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested centroiding parameters
|
||||
*/
|
||||
class CentroidingSet : public StaticLocalDataSet<CENTROIDING_PARAMS_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 49;
|
||||
|
||||
CentroidingSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CENTROIDING_SET_ID) {}
|
||||
|
||||
CentroidingSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, CENTROIDING_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> enableFilter =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::CENTROIDING_ENABLE_FILTER, this);
|
||||
lp_var_t<float> maxQuality =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_MAX_QUALITY, this);
|
||||
lp_var_t<float> darkThreshold =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_DARK_THRESHOLD, this);
|
||||
lp_var_t<float> minQuality =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_MIN_QUALITY, this);
|
||||
lp_var_t<float> maxIntensity =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_MAX_INTENSITY, this);
|
||||
lp_var_t<float> minIntensity =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_MIN_INTENSITY, this);
|
||||
lp_var_t<float> maxMagnitude =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_MAX_MAGNITUDE, this);
|
||||
lp_var_t<float> gaussianCmax =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_GAUSSIAN_CMAX, this);
|
||||
lp_var_t<float> gaussianCmin =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_GAUSSIAN_CMIN, this);
|
||||
lp_var_t<float> transmatrix00 =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_TRANSMATRIX00, this);
|
||||
lp_var_t<float> transmatrix01 =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_TRANSMATRIX01, this);
|
||||
lp_var_t<float> transmatrix10 =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_TRANSMATRIX10, this);
|
||||
lp_var_t<float> transmatrix11 =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::CENTROIDING_TRANSMATRIX11, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "CentroidingSet::printSet: enable filter: " << this->enableFilter << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: max quality: " << this->maxQuality << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: dark threshold: " << this->darkThreshold << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: min quality: " << this->minQuality << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: max intensity: " << this->maxIntensity << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: min intensity: " << this->minIntensity << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: max magnitude: " << this->maxMagnitude << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: gaussian cmax: " << this->gaussianCmax << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: gaussian cmin: " << this->gaussianCmin << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: transmatrix 00 : " << this->transmatrix00 << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: transmatrix 01 : " << this->transmatrix01 << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: transmatrix 10 : " << this->transmatrix10 << std::endl;
|
||||
sif::info << "CentroidingSet::printSet: transmatrix 11 : " << this->transmatrix11 << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested centroiding parameters
|
||||
*/
|
||||
class LisaSet : public StaticLocalDataSet<LISA_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 50;
|
||||
|
||||
LisaSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LISA_SET_ID) {}
|
||||
|
||||
LisaSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LISA_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint32_t> mode = lp_var_t<uint32_t>(sid.objectId, PoolIds::LISA_MODE, this);
|
||||
lp_var_t<float> prefilterDistThreshold =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_PREFILTER_DIST_THRESHOLD, this);
|
||||
lp_var_t<float> prefilterAngleThreshold =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_PREFILTER_ANGLE_THRESHOLD, this);
|
||||
lp_var_t<float> fovWidth = lp_var_t<float>(sid.objectId, PoolIds::LISA_FOV_WIDTH, this);
|
||||
lp_var_t<float> fovHeight = lp_var_t<float>(sid.objectId, PoolIds::LISA_FOV_HEIGHT, this);
|
||||
lp_var_t<float> floatStarLimit =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_FLOAT_STAR_LIMIT, this);
|
||||
lp_var_t<float> closeStarLimit =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_CLOSE_STAR_LIMIT, this);
|
||||
lp_var_t<float> ratingWeightCloseStarCount =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_RATING_WEIGHT_CLOSE_STAR_COUNT, this);
|
||||
lp_var_t<float> ratingWeightFractionClose =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_RATING_WEIGHT_FRACTION_CLOSE, this);
|
||||
lp_var_t<float> ratingWeightMeanSum =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_RATING_WEIGHT_MEAN_SUM, this);
|
||||
lp_var_t<float> ratingWeightDbStarCount =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_RATING_WEIGHT_DB_STAR_COUNT, this);
|
||||
lp_var_t<uint8_t> maxCombinations =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LISA_MAX_COMBINATIONS, this);
|
||||
lp_var_t<uint8_t> nrStarsStop =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LISA_NR_STARS_STOP, this);
|
||||
lp_var_t<float> fractionCloseStop =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::LISA_FRACTION_CLOSE_STOP, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "LisaSet::printSet: mode: " << this->mode << std::endl;
|
||||
sif::info << "LisaSet::printSet: prefilter dist threshold: " << this->prefilterDistThreshold
|
||||
<< std::endl;
|
||||
sif::info << "LisaSet::printSet: prefilter angle threshold: " << this->prefilterAngleThreshold
|
||||
<< std::endl;
|
||||
sif::info << "LisaSet::printSet: fov width: " << this->fovWidth << std::endl;
|
||||
sif::info << "LisaSet::printSet: fov height: " << this->fovHeight << std::endl;
|
||||
sif::info << "LisaSet::printSet: float star limit: " << this->floatStarLimit << std::endl;
|
||||
sif::info << "LisaSet::printSet: close star limit: " << this->closeStarLimit << std::endl;
|
||||
sif::info << "LisaSet::printSet: rating weight close star count: "
|
||||
<< this->ratingWeightCloseStarCount << std::endl;
|
||||
sif::info << "LisaSet::printSet: rating weight fraction close: "
|
||||
<< this->ratingWeightFractionClose << std::endl;
|
||||
sif::info << "LisaSet::printSet: rating weight mean sum: " << this->ratingWeightMeanSum
|
||||
<< std::endl;
|
||||
sif::info << "LisaSet::printSet: rating weight db star count: " << this->ratingWeightDbStarCount
|
||||
<< std::endl;
|
||||
sif::info << "LisaSet::printSet: max combinations: " << this->maxCombinations << std::endl;
|
||||
sif::info << "LisaSet::printSet: nr stars stop: " << this->nrStarsStop << std::endl;
|
||||
sif::info << "LisaSet::printSet: fraction close stop: " << this->fractionCloseStop << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested matching parameters
|
||||
*/
|
||||
class MatchingSet : public StaticLocalDataSet<MATCHING_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 8;
|
||||
|
||||
MatchingSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, MATCHING_SET_ID) {}
|
||||
|
||||
MatchingSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, MATCHING_SET_ID)) {}
|
||||
|
||||
lp_var_t<float> squaredDistanceLimit = lp_var_t<float>(sid.objectId, PoolIds::MATCHING_SQUARED_DISTANCE_LIMIT, this);
|
||||
lp_var_t<float> squaredShiftLimit = lp_var_t<float>(sid.objectId, PoolIds::MATCHING_SQUARED_SHIFT_LIMIT, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredDistanceLimit
|
||||
<< std::endl;
|
||||
sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredShiftLimit
|
||||
<< std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested tracking parameters
|
||||
*/
|
||||
class TrackingSet : public StaticLocalDataSet<TRACKING_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 16;
|
||||
|
||||
TrackingSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TRACKING_SET_ID) {}
|
||||
|
||||
TrackingSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TRACKING_SET_ID)) {}
|
||||
|
||||
lp_var_t<float> thinLimit = lp_var_t<float>(sid.objectId, PoolIds::TRACKING_THIN_LIMIT, this);
|
||||
lp_var_t<float> outlierThreshold = lp_var_t<float>(sid.objectId, PoolIds::TRACKING_OUTLIER_THRESHOLD, this);
|
||||
lp_var_t<float> outlierThresholdQuest = lp_var_t<float>(sid.objectId, PoolIds::TRACKING_OUTLIER_THRESHOLD_QUEST, this);
|
||||
lp_var_t<float> trackerChoice = lp_var_t<float>(sid.objectId, PoolIds::TRACKING_TRACKER_CHOICE, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredDistanceLimit
|
||||
<< std::endl;
|
||||
sif::info << "MatchingSet::printSet: squared distance limit: " << this->squaredShiftLimit
|
||||
<< std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested validation parameters
|
||||
*/
|
||||
class ValidationSet : public StaticLocalDataSet<VALIDATION_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 10;
|
||||
|
||||
ValidationSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, VALIDATION_SET_ID) {}
|
||||
|
||||
ValidationSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, VALIDATION_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> stableCount =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::VALIDATION_STABLE_COUNT, this);
|
||||
lp_var_t<float> maxDifference =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::VALIDATION_MAX_DIFFERENCE, this);
|
||||
lp_var_t<float> minTrackerConfidence =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::VALIDATION_MIN_TRACKER_CONFIDENCE, this);
|
||||
lp_var_t<uint8_t> minMatchedStars =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::VALIDATION_MIN_MATCHED_STARS, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "ValidationSet::printSet: stable count: "
|
||||
<< static_cast<unsigned int>(this->stableCount) << std::endl;
|
||||
sif::info << "ValidationSet::printSet: max difference: " << this->maxDifference << std::endl;
|
||||
sif::info << "ValidationSet::printSet: min tracker confidence: " << this->minTrackerConfidence
|
||||
<< std::endl;
|
||||
sif::info << "ValidationSet::printSet: min matched stars: " << this->minMatchedStars
|
||||
<< std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested algo parameters
|
||||
*/
|
||||
class AlgoSet : public StaticLocalDataSet<ALGO_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 11;
|
||||
|
||||
AlgoSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, ALGO_SET_ID) {}
|
||||
|
||||
AlgoSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, ALGO_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> mode =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::ALGO_MODE, this);
|
||||
lp_var_t<float> i2tMinConfidence =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::ALGO_I2T_MIN_CONFIDENCE, this);
|
||||
lp_var_t<uint8_t> i2tMinMatched =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::ALGO_I2T_MIN_MATCHED, this);
|
||||
lp_var_t<float> i2lMinConfidence =
|
||||
lp_var_t<float>(sid.objectId, PoolIds::ALGO_I2L_MIN_CONFIDENCE, this);
|
||||
lp_var_t<uint8_t> i2lMinMatched =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::ALGO_I2L_MIN_MATCHED, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "AlgoSet::printSet: mode: " << static_cast<unsigned int>(this->mode) << std::endl;
|
||||
sif::info << "AlgoSet::printSet: i2t min confidence: " << this->i2tMinConfidence << std::endl;
|
||||
sif::info << "AlgoSet::printSet: i2t min matched: "
|
||||
<< static_cast<unsigned int>(this->i2tMinMatched) << std::endl;
|
||||
sif::info << "AlgoSet::printSet: i2l min confidence: " << this->i2lMinConfidence << std::endl;
|
||||
sif::info << "AlgoSet::printSet: i2l min matched: "
|
||||
<< static_cast<unsigned int>(this->i2lMinMatched) << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested subscription parameters
|
||||
*/
|
||||
class SubscriptionSet : public StaticLocalDataSet<SUBSCRIPTION_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 16;
|
||||
|
||||
SubscriptionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SUBSCRIPTION_SET_ID) {}
|
||||
|
||||
SubscriptionSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, SUBSCRIPTION_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> tm1 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM1, this);
|
||||
lp_var_t<uint8_t> tm2 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM2, this);
|
||||
lp_var_t<uint8_t> tm3 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM3, this);
|
||||
lp_var_t<uint8_t> tm4 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM4, this);
|
||||
lp_var_t<uint8_t> tm5 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM5, this);
|
||||
lp_var_t<uint8_t> tm6 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM6, this);
|
||||
lp_var_t<uint8_t> tm7 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM7, this);
|
||||
lp_var_t<uint8_t> tm8 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM8, this);
|
||||
lp_var_t<uint8_t> tm9 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM9, this);
|
||||
lp_var_t<uint8_t> tm10 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM10, this);
|
||||
lp_var_t<uint8_t> tm11 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM11, this);
|
||||
lp_var_t<uint8_t> tm12 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM12, this);
|
||||
lp_var_t<uint8_t> tm13 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM13, this);
|
||||
lp_var_t<uint8_t> tm14 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM14, this);
|
||||
lp_var_t<uint8_t> tm15 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM15, this);
|
||||
lp_var_t<uint8_t> tm16 = lp_var_t<uint8_t>(sid.objectId, PoolIds::SUBSCRIPTION_TM16, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 1: " << static_cast<unsigned int>(this->tm1)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 2: " << static_cast<unsigned int>(this->tm2)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 3: " << static_cast<unsigned int>(this->tm3)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 4: " << static_cast<unsigned int>(this->tm4)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 5: " << static_cast<unsigned int>(this->tm5)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 6: " << static_cast<unsigned int>(this->tm6)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 7: " << static_cast<unsigned int>(this->tm7)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 8: " << static_cast<unsigned int>(this->tm8)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 9: " << static_cast<unsigned int>(this->tm9)
|
||||
<< std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 10: "
|
||||
<< static_cast<unsigned int>(this->tm10) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 11: "
|
||||
<< static_cast<unsigned int>(this->tm11) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 12: "
|
||||
<< static_cast<unsigned int>(this->tm12) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 13: "
|
||||
<< static_cast<unsigned int>(this->tm13) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 14: "
|
||||
<< static_cast<unsigned int>(this->tm14) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 15: "
|
||||
<< static_cast<unsigned int>(this->tm15) << std::endl;
|
||||
sif::info << "SubscriptionSet::printSet: telemetry 16: "
|
||||
<< static_cast<unsigned int>(this->tm16) << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested log subscription parameters
|
||||
*/
|
||||
class LogSubscriptionSet : public StaticLocalDataSet<LOG_SUBSCRIPTION_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 4;
|
||||
|
||||
LogSubscriptionSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, LOG_SUBSCRIPTION_SET_ID) {}
|
||||
|
||||
LogSubscriptionSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, LOG_SUBSCRIPTION_SET_ID)) {}
|
||||
|
||||
lp_var_t<uint8_t> level1 =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LOG_SUBSCRIPTION_LEVEL1, this);
|
||||
lp_var_t<uint8_t> module1 =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LOG_SUBSCRIPTION_MODULE1, this);
|
||||
lp_var_t<uint8_t> level2 =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LOG_SUBSCRIPTION_LEVEL2, this);
|
||||
lp_var_t<uint8_t> module2 =
|
||||
lp_var_t<uint8_t>(sid.objectId, PoolIds::LOG_SUBSCRIPTION_MODULE2, this);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "LogSubscriptionSet::printSet: level 1: "
|
||||
<< static_cast<unsigned int>(this->level1) << std::endl;
|
||||
sif::info << "LogSubscriptionSet::printSet: module 1: "
|
||||
<< static_cast<unsigned int>(this->module1) << std::endl;
|
||||
sif::info << "LogSubscriptionSet::printSet: level 2: "
|
||||
<< static_cast<unsigned int>(this->level2) << std::endl;
|
||||
sif::info << "LogSubscriptionSet::printSet: module 2: "
|
||||
<< static_cast<unsigned int>(this->module2) << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Will store the requested debug camera parameters
|
||||
*/
|
||||
class DebugCameraSet : public StaticLocalDataSet<DEBUG_CAMERA_SET_ENTRIES> {
|
||||
public:
|
||||
// Size of dataset
|
||||
static const size_t SIZE = 8;
|
||||
|
||||
DebugCameraSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, DEBUG_CAMERA_SET_ID) {}
|
||||
|
||||
lp_var_t<uint32_t> timing =
|
||||
lp_var_t<uint32_t>(sid.objectId, PoolIds::DEBUG_CAMERA_TIMING, this);
|
||||
lp_var_t<uint32_t> test =
|
||||
lp_var_t<uint32_t>(sid.objectId, PoolIds::DEBUG_CAMERA_TEST, this);
|
||||
|
||||
DebugCameraSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, DEBUG_CAMERA_SET_ID)) {}
|
||||
|
||||
void printSet() {
|
||||
sif::info << "DebugCameraSet::printSet: level 1: "
|
||||
<< static_cast<unsigned int>(this->level1) << std::endl;
|
||||
sif::info << "DebugCameraSet::printSet: module 1: "
|
||||
<< static_cast<unsigned int>(this->module1) << std::endl;
|
||||
}
|
||||
};
|
||||
} // namespace StarTracker
|
||||
|
||||
@ -515,6 +515,50 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
|
||||
result = prepareRequestLimitsParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_LOG_LEVEL): {
|
||||
result = prepareRequestLogLevelParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_MOUNTING): {
|
||||
result = prepareRequestMountingParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_IMAGE_PROCESSOR): {
|
||||
result = prepareRequestMountignParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_CENTROIDING): {
|
||||
result = prepareRequestCentroidingParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_LISA): {
|
||||
result = prepareRequestLisaParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_MATCHING): {
|
||||
result = prepareRequetMatchingParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_TRACKING): {
|
||||
result = prepareRequestTrackingParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_VALIDATION): {
|
||||
result = prepareRequestValidationParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_ALGO): {
|
||||
result = prepareRequestAlgoParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_SUBSCRIPTION): {
|
||||
result = prepareRequestSubscriptionParams();
|
||||
return result;
|
||||
}
|
||||
case (StarTracker::REQ_LOG_SUBSCRIPTION): {
|
||||
result = prepareRequestLogSubscriptionParams();
|
||||
return result;
|
||||
}
|
||||
default:
|
||||
return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
|
||||
}
|
||||
@ -599,6 +643,30 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_LIMITS, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_LOG_LEVEL, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_MOUNTING, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_IMAGE_PROCESSOR, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_CENTROIDING, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_LISA, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_MATCHING, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_TRACKING, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_VALIDATION, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_ALGO, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_SUBSCRIPTION, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_LOG_SUBSCRIPTION, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
this->insertInCommandAndReplyMap(StarTracker::REQ_DEBUG_CAMERA, 3, nullptr,
|
||||
StarTracker::MAX_FRAME_SIZE * 2 + 2);
|
||||
}
|
||||
|
||||
ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t remainingSize,
|
||||
@ -983,6 +1051,15 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL3, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_REG4, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL4, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_REG5, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL5, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_REG6, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL6, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_REG7, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL7, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_REG8, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_VAL8, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CAM_FREQ_1, new PoolEntry<uint8_t>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::LIMITS_ACTION, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LIMITS_FPGA18CURRENT, new PoolEntry<float>({0}));
|
||||
@ -994,6 +1071,77 @@ 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::LOGLEVEL1, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL2, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL3, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL4, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL5, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL6, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL7, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL8, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL9, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL10, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL11, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL12, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL13, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL14, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL15, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LOGLEVEL16, new PoolEntry<uint8_t>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::MOUNTING_QW, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::MOUNTING_QX, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::MOUNTING_QY, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::MOUNTING_QZ, new PoolEntry<float>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::IMAGE_PROCESSOR_MODE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::IMAGE_PROCESSOR_STORE, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::IMAGE_PROCESSOR_SIGNALTHRESHOLD, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::IMAGE_PROCESSOR_DARKTHRESHOLD, new PoolEntry<uint16_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::IMAGE_PROCESSOR_BACKGROUNDCOMPENSATION, new PoolEntry<uint8_t>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_ENABLE_FILTER, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_MAX_QUALITY, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_DARK_THRESHOLD, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_MIN_QUALITY, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_MAX_INTENSITY, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_MIN_INTENSITY, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_MAX_MAGNITUDE, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_GAUSSIAN_CMAX, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_GAUSSIAN_CMIN, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_TRANSMATRIX00, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_TRANSMATRIX01, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_TRANSMATRIX10, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::CENTROIDING_TRANSMATRIX11, new PoolEntry<float>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::LISA_MODE, new PoolEntry<uint32_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_PREFILTER_DIST_THRESHOLD, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_PREFILTER_ANGLE_THRESHOLD, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_FOV_WIDTH, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_FOV_HEIGHT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_FLOAT_STAR_LIMIT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_CLOSE_STAR_LIMIT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_RATING_WEIGHT_CLOSE_STAR_COUNT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_RATING_WEIGHT_FRACTION_CLOSE, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_RATING_WEIGHT_MEAN_SUM, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_RATING_WEIGHT_DB_STAR_COUNT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_MAX_COMBINATIONS, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_NR_STARS_STOP, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::LISA_FRACTION_CLOSE_STOP, new PoolEntry<float>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::MATCHING_SQUARED_DISTANCE_LIMIT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::MATCHING_SQUARED_SHIFT_LIMIT, new PoolEntry<float>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::TRACKING_THIN_LIMIT, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::TRACKING_OUTLIER_THRESHOLD, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::TRACKING_OUTLIER_THRESHOLD_QUEST, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::TRACKING_TRACKER_CHOICE, new PoolEntry<float>({0}));
|
||||
|
||||
localDataPoolMap.emplace(StarTracker::VALIDATION_STABLE_COUNT, new PoolEntry<uint8_t>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::VALIDATION_MAX_DIFFERENCE, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::VALIDATION_MIN_TRACKER_CONFIDENCE, new PoolEntry<float>({0}));
|
||||
localDataPoolMap.emplace(StarTracker::VALIDATION_MIN_MATCHED_STARS, new PoolEntry<uint8_t>({0}));
|
||||
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
@ -1099,7 +1247,7 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t* foundId)
|
||||
ReturnValue_t StarTrackerHandler::scanForSetParameterReply(DeviceCommandId_t* foundId) {
|
||||
const uint8_t* reply = dataLinkLayer.getReply();
|
||||
switch (*reply) {
|
||||
case (StarTracker::ID::SUBSCRIBE): {
|
||||
case (StarTracker::ID::SUBSCRIPTION): {
|
||||
*foundId = StarTracker::SUBSCRIBE_TO_TM;
|
||||
break;
|
||||
}
|
||||
@ -1162,6 +1310,54 @@ ReturnValue_t StarTrackerHandler::scanForGetParameterReply(DeviceCommandId_t* fo
|
||||
*foundId = StarTracker::REQ_LIMITS;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::LOG_LEVEL): {
|
||||
*foundId = StarTracker::REQ_LOG_LEVEL;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::MOUNTING): {
|
||||
*foundId = StarTracker::REQ_MOUNTING;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::IMAGE_PROCESSOR): {
|
||||
*foundId = StarTracker::REQ_IMAGE_PROCESSOR;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::CENTROIDING): {
|
||||
*foundId = StarTracker::REQ_CENTROIDING;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::LISA): {
|
||||
*foundId = StarTracker::REQ_LISA;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::MATCHING): {
|
||||
*foundId = StarTracker::REQ_MATCHING;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::TRACKING): {
|
||||
*foundId = StarTracker::REQ_TRACKING;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::VALIDATION): {
|
||||
*foundId = StarTracker::REQ_VALIDATION;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::ALGO): {
|
||||
*foundId = StarTracker::REQ_ALGO;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::SUBSCRIPTION): {
|
||||
*foundId = StarTracker::SUBSCRIPTION;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::LOG_SUBSCRIPTION): {
|
||||
*foundId = StarTracker::REQ_LOG_SUBSCRIPTION;
|
||||
break;
|
||||
}
|
||||
case (StarTracker::ID::DEBUG_CAMERA): {
|
||||
*foundId = StarTracker::REQ_DEBUG_CAMERA;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
sif::warning << "tarTrackerHandler::scanForGetParameterReply: UnkNown ID" << std::endl;
|
||||
return RETURN_FAILED;
|
||||
@ -1626,7 +1822,7 @@ void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
|
||||
void StarTrackerHandler::prepareSubscriptionCommand(const uint8_t* tmId) {
|
||||
uint32_t length = 18;
|
||||
commandBuffer[0] = TMTC_SETPARAMREQ;
|
||||
commandBuffer[1] = StarTracker::ID::SUBSCRIBE;
|
||||
commandBuffer[1] = StarTracker::ID::SUBSCRIPTION;
|
||||
// Fill all other fields with invalid tm id
|
||||
commandBuffer[2] = *tmId;
|
||||
commandBuffer[3] = 0;
|
||||
@ -1794,6 +1990,15 @@ ReturnValue_t StarTrackerHandler::prepareRequestLimitsParams() {
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t StarTrackerHandler::prepareRequestPropertyParams() {
|
||||
uint32_t length = 0;
|
||||
arc_pack_loglevel_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);
|
||||
|
||||
@ -495,14 +495,23 @@ class StarTrackerHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t prepareFpgaActionCommand(const uint8_t* commandData, size_t commandDataLen);
|
||||
|
||||
/**
|
||||
* @brief Will fill the command buffer with the command to request the set camera parameters.
|
||||
* @brief The following function will fill the command buffer with the command to request
|
||||
* a parameter set.
|
||||
*/
|
||||
ReturnValue_t prepareRequestCameraParams();
|
||||
|
||||
/**
|
||||
* @brief Will fill the command buffer with the command to request the set limits.
|
||||
*/
|
||||
ReturnValue_t prepareRequestLimitsParams();
|
||||
ReturnValue_t prepareRequestLogLevelParams();
|
||||
ReturnValue_t prepareRequestMountingParams();
|
||||
ReturnValue_t prepareRequestImageProcessorParams();
|
||||
ReturnValue_t prepareRequestCentroidingParams();
|
||||
ReturnValue_t prepareRequestLisaParams();
|
||||
ReturnValue_t prepareRequestMatchingParams();
|
||||
ReturnValue_t prepareRequestTrackingParams();
|
||||
ReturnValue_t prepareRequestValidationParams();
|
||||
ReturnValue_t prepareRequestAlgoParams();
|
||||
ReturnValue_t prepareRequestSubscriptionParams();
|
||||
ReturnValue_t prepareRequestLogSubscriptionParams();
|
||||
ReturnValue_t prepareRequestDebugCameraParams();
|
||||
|
||||
/**
|
||||
* @brief Handles action replies with datasets.
|
||||
|
||||
2
tmtc
2
tmtc
@ -1 +1 @@
|
||||
Subproject commit 199ffe1a321c09ba9726c87413045f8b32f40e90
|
||||
Subproject commit cf7d25c206e8ae8480367e1fc2b1151a0ded2683
|
||||
Loading…
Reference in New Issue
Block a user