1732 lines
78 KiB
C++
1732 lines
78 KiB
C++
#ifndef LINUX_DEVICES_DEVICEDEFINITIONS_STARTRACKER_DEFINITIONS_H_
|
|
#define LINUX_DEVICES_DEVICEDEFINITIONS_STARTRACKER_DEFINITIONS_H_
|
|
|
|
#include <fsfw/datapool/PoolReadGuard.h>
|
|
#include <fsfw/datapoollocal/LocalPoolVariable.h>
|
|
#include <fsfw/datapoollocal/StaticLocalDataSet.h>
|
|
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
|
|
#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
|
|
|
|
#include <optional>
|
|
|
|
namespace startracker {
|
|
|
|
static const Submode_t SUBMODE_BOOTLOADER = 1;
|
|
static const Submode_t SUBMODE_FIRMWARE = 2;
|
|
|
|
enum class FirmwareTarget : uint8_t { MAIN = 1, BACKUP = 10 };
|
|
|
|
static constexpr char FW_TARGET_CFG_PATH[] = "startracker/fw-target.txt";
|
|
|
|
enum ParamId : uint32_t { FIRMWARE_TARGET = 1, FIRMWARE_TARGET_PERSISTENT = 2 };
|
|
|
|
class SdCardConfigPathGetter {
|
|
public:
|
|
virtual ~SdCardConfigPathGetter() = default;
|
|
virtual std::optional<std::string> getCfgPath() = 0;
|
|
};
|
|
|
|
/**
|
|
* @brief Returns the frame type field of a decoded frame.
|
|
*/
|
|
uint8_t getReplyFrameType(const uint8_t* rawFrame);
|
|
uint8_t getId(const uint8_t* rawFrame);
|
|
uint8_t getStatusField(const uint8_t* rawFrame);
|
|
|
|
/** This is the address of the star tracker */
|
|
static const uint8_t ADDRESS = 33;
|
|
|
|
static const uint8_t STATUS_OK = 0;
|
|
|
|
enum PoolIds : lp_id_t {
|
|
TICKS_TIME_SET,
|
|
TIME_TIME_SET,
|
|
RUN_TIME,
|
|
UNIX_TIME,
|
|
TICKS_VERSION_SET,
|
|
TIME_VERSION_SET,
|
|
PROGRAM,
|
|
MAJOR,
|
|
MINOR,
|
|
TICKS_INTERFACE_SET,
|
|
TIME_INTERFACE_SET,
|
|
FRAME_COUNT,
|
|
CHECKSUM_ERROR_COUNT,
|
|
SET_PARAM_COUNT,
|
|
SET_PARAM_REPLY_COUNT,
|
|
PARAM_REQUEST_COUNT,
|
|
PARAM_REPLY_COUNT,
|
|
REQ_TM_COUNT,
|
|
TM_REPLY_COUNT,
|
|
ACTION_REQ_COUNT,
|
|
ACTION_REPLY_COUNT,
|
|
TICKS_POWER_SET,
|
|
TIME_POWER_SET,
|
|
MCU_CURRENT,
|
|
MCU_VOLTAGE,
|
|
FPGA_CORE_CURRENT,
|
|
FPGA_CORE_VOLTAGE,
|
|
FPGA_18_CURRENT,
|
|
FPGA_18_VOLTAGE,
|
|
FPGA_25_CURRENT,
|
|
FPGA_25_VOLTAGE,
|
|
CMV_21_CURRENT,
|
|
CMV_21_VOLTAGE,
|
|
CMV_PIX_CURRENT,
|
|
CMV_PIX_VOLTAGE,
|
|
CMV_33_CURRENT,
|
|
CMV_33_VOLTAGE,
|
|
CMV_RES_CURRENT,
|
|
CMV_RES_VOLTAGE,
|
|
TICKS_TEMPERATURE_SET,
|
|
TIME_TEMPERATURE_SET,
|
|
MCU_TEMPERATURE,
|
|
CMOS_TEMPERATURE,
|
|
FPGA_TEMPERATURE,
|
|
TICKS_SOLUTION_SET,
|
|
TIME_SOLUTION_SET,
|
|
CALI_QW,
|
|
CALI_QX,
|
|
CALI_QY,
|
|
CALI_QZ,
|
|
TRACK_CONFIDENCE,
|
|
TRACK_QW,
|
|
TRACK_QX,
|
|
TRACK_QY,
|
|
TRACK_QZ,
|
|
TRACK_REMOVED,
|
|
STARS_CENTROIDED,
|
|
STARS_MATCHED_DATABASE,
|
|
LISA_QW,
|
|
LISA_QX,
|
|
LISA_QY,
|
|
LISA_QZ,
|
|
LISA_PERC_CLOSE,
|
|
LISA_NR_CLOSE,
|
|
STR_MODE,
|
|
TRUST_WORTHY,
|
|
STABLE_COUNT,
|
|
SOLUTION_STRATEGY,
|
|
TICKS_HISTOGRAM_SET,
|
|
TIME_HISTOGRAM_SET,
|
|
HISTOGRAM_BINA0,
|
|
HISTOGRAM_BINA1,
|
|
HISTOGRAM_BINA2,
|
|
HISTOGRAM_BINA3,
|
|
HISTOGRAM_BINA4,
|
|
HISTOGRAM_BINA5,
|
|
HISTOGRAM_BINA6,
|
|
HISTOGRAM_BINA7,
|
|
HISTOGRAM_BINA8,
|
|
HISTOGRAM_BINB0,
|
|
HISTOGRAM_BINB1,
|
|
HISTOGRAM_BINB2,
|
|
HISTOGRAM_BINB3,
|
|
HISTOGRAM_BINB4,
|
|
HISTOGRAM_BINB5,
|
|
HISTOGRAM_BINB6,
|
|
HISTOGRAM_BINB7,
|
|
HISTOGRAM_BINB8,
|
|
HISTOGRAM_BINC0,
|
|
HISTOGRAM_BINC1,
|
|
HISTOGRAM_BINC2,
|
|
HISTOGRAM_BINC3,
|
|
HISTOGRAM_BINC4,
|
|
HISTOGRAM_BINC5,
|
|
HISTOGRAM_BINC6,
|
|
HISTOGRAM_BINC7,
|
|
HISTOGRAM_BINC8,
|
|
HISTOGRAM_BIND0,
|
|
HISTOGRAM_BIND1,
|
|
HISTOGRAM_BIND2,
|
|
HISTOGRAM_BIND3,
|
|
HISTOGRAM_BIND4,
|
|
HISTOGRAM_BIND5,
|
|
HISTOGRAM_BIND6,
|
|
HISTOGRAM_BIND7,
|
|
HISTOGRAM_BIND8,
|
|
CHKSUM,
|
|
CAMERA_MODE,
|
|
FOCALLENGTH,
|
|
EXPOSURE,
|
|
INTERVAL,
|
|
CAMERA_OFFSET,
|
|
PGAGAIN,
|
|
ADCGAIN,
|
|
CAM_REG1,
|
|
CAM_VAL1,
|
|
CAM_REG2,
|
|
CAM_VAL2,
|
|
CAM_REG3,
|
|
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,
|
|
LIMITS_FPGA10CURRENT,
|
|
LIMITS_MCUCURRENT,
|
|
LIMITS_CMOS21CURRENT,
|
|
LIMITS_CMOSPIXCURRENT,
|
|
LIMITS_CMOS33CURRENT,
|
|
LIMITS_CMOSVRESCURRENT,
|
|
LIMITS_CMOSTEMPERATURE,
|
|
LIMITS_MCUTEMPERATURE,
|
|
BLOB_MODE,
|
|
BLOB_MIN_VALUE,
|
|
BLOB_MIN_DISTANCE,
|
|
BLOB_NEIGHBOUR_DISTANCE,
|
|
BLOB_NEIGHBOUR_BRIGHTPIXELS,
|
|
BLOB_MIN_TOTAL_VALUE,
|
|
BLOB_MAX_TOTAL_VALUE,
|
|
BLOB_MIN_BRIGHT_NEIGHBOURS,
|
|
BLOB_MAX_BRIGHT_NEIGHBOURS,
|
|
BLOB_MAX_PIXELSTOCONSIDER,
|
|
BLOB_SIGNAL_THRESHOLD,
|
|
BLOB_DARK_THRESHOLD,
|
|
BLOB_ENABLE_HISTOGRAM,
|
|
BLOB_ENABLE_CONTRAST,
|
|
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,
|
|
|
|
TICKS_AUTO_BLOB,
|
|
TIME_AUTO_BLOB,
|
|
AUTO_BLOB_THRESHOLD,
|
|
|
|
TICKS_MATCHED_CENTROIDS,
|
|
TIME_MATCHED_CENTROIDS,
|
|
NUM_MATCHED_CENTROIDS,
|
|
MATCHED_CENTROIDS_STAR_IDS,
|
|
MATCHED_CENTROIDS_X_COORDS,
|
|
MATCHED_CENTROIDS_Y_COORDS,
|
|
MATCHED_CENTROIDS_X_ERRORS,
|
|
MATCHED_CENTROIDS_Y_ERRORS,
|
|
|
|
BLOB_TICKS,
|
|
BLOB_TIME,
|
|
BLOB_COUNT,
|
|
|
|
BLOBS_TICKS,
|
|
BLOBS_TIME,
|
|
BLOBS_COUNT,
|
|
BLOBS_COUNT_USED,
|
|
BLOBS_NR_4LINES_SKIPPED,
|
|
BLOBS_X_COORDS,
|
|
BLOBS_Y_COORDS,
|
|
|
|
CENTROID_TICKS,
|
|
CENTROID_TIME,
|
|
CENTROID_COUNT,
|
|
|
|
CENTROIDS_TICKS,
|
|
CENTROIDS_TIME,
|
|
CENTROIDS_COUNT,
|
|
CENTROIDS_X_COORDS,
|
|
CENTROIDS_Y_COORDS,
|
|
CENTROIDS_MAGNITUDES,
|
|
|
|
CONTRAST_TICKS,
|
|
CONTRAST_TIME,
|
|
CONTRAST_A,
|
|
CONTRAST_B,
|
|
CONTRAST_C,
|
|
CONTRAST_D,
|
|
};
|
|
|
|
static const DeviceCommandId_t PING_REQUEST = 0;
|
|
// Boots image (works only in bootloader mode)
|
|
static const DeviceCommandId_t BOOT = 1;
|
|
static const DeviceCommandId_t REQ_VERSION = 2;
|
|
static const DeviceCommandId_t REQ_INTERFACE = 3;
|
|
static const DeviceCommandId_t REQ_TIME = 4;
|
|
static const DeviceCommandId_t SWITCH_TO_BOOTLOADER_PROGRAM = 7;
|
|
static const DeviceCommandId_t DOWNLOAD_IMAGE = 9;
|
|
static const DeviceCommandId_t UPLOAD_IMAGE = 10;
|
|
static const DeviceCommandId_t REQ_POWER = 11;
|
|
static const DeviceCommandId_t TAKE_IMAGE = 15;
|
|
static const DeviceCommandId_t SUBSCRIPTION = 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;
|
|
static constexpr 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 CENTROIDING = 44;
|
|
static const DeviceCommandId_t LISA = 45;
|
|
static const DeviceCommandId_t MATCHING = 46;
|
|
static const DeviceCommandId_t TRACKING = 47;
|
|
static const DeviceCommandId_t VALIDATION = 48;
|
|
static const DeviceCommandId_t ALGO = 49;
|
|
static const DeviceCommandId_t CHECKSUM = 50;
|
|
static const DeviceCommandId_t FLASH_READ = 51;
|
|
static const DeviceCommandId_t STOP_IMAGE_LOADER = 55;
|
|
static const DeviceCommandId_t CHANGE_IMAGE_DOWNLOAD_FILE = 57;
|
|
static const DeviceCommandId_t SET_JSON_FILE_NAME = 58;
|
|
static const DeviceCommandId_t SET_FLASH_READ_FILENAME = 59;
|
|
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 LOGLEVEL = 81;
|
|
static const DeviceCommandId_t LOGSUBSCRIPTION = 82;
|
|
static const DeviceCommandId_t DEBUG_CAMERA = 83;
|
|
static const DeviceCommandId_t FIRMWARE_UPDATE_MAIN = 84;
|
|
static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
|
|
static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
|
|
static constexpr DeviceCommandId_t SET_TIME_FROM_SYS_TIME = 87;
|
|
static constexpr DeviceCommandId_t AUTO_THRESHOLD = 88;
|
|
static constexpr DeviceCommandId_t REQ_AUTO_BLOB = 89;
|
|
static constexpr DeviceCommandId_t REQ_MATCHED_CENTROIDS = 90;
|
|
static constexpr DeviceCommandId_t REQ_BLOB = 91;
|
|
static constexpr DeviceCommandId_t REQ_BLOBS = 92;
|
|
static constexpr DeviceCommandId_t REQ_CENTROID = 93;
|
|
static constexpr DeviceCommandId_t REQ_CENTROIDS = 94;
|
|
static constexpr DeviceCommandId_t ADD_SECONDARY_TM_TO_NORMAL_MODE = 95;
|
|
static constexpr DeviceCommandId_t RESET_SECONDARY_TM_SET = 96;
|
|
static constexpr DeviceCommandId_t READ_SECONDARY_TM_SET = 97;
|
|
static constexpr DeviceCommandId_t RELOAD_JSON_CFG_FILE = 100;
|
|
static const DeviceCommandId_t FIRMWARE_UPDATE_BACKUP = 101;
|
|
static const DeviceCommandId_t NONE = 0xFFFFFFFF;
|
|
|
|
static const uint32_t VERSION_SET_ID = REQ_VERSION;
|
|
static const uint32_t INTERFACE_SET_ID = REQ_INTERFACE;
|
|
static const uint32_t POWER_SET_ID = REQ_POWER;
|
|
static const uint32_t TEMPERATURE_SET_ID = REQ_TEMPERATURE;
|
|
static const uint32_t TIME_SET_ID = REQ_TIME;
|
|
static const uint32_t SOLUTION_SET_ID = REQ_SOLUTION;
|
|
static const uint32_t HISTOGRAM_SET_ID = REQ_HISTOGRAM;
|
|
static const uint32_t CHECKSUM_SET_ID = CHECKSUM;
|
|
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;
|
|
static const uint32_t DEBUG_CAMERA_SET_ID = REQ_DEBUG_CAMERA;
|
|
static const uint32_t AUTO_BLOB_SET_ID = REQ_AUTO_BLOB;
|
|
static const uint32_t MATCHED_CENTROIDS_SET_ID = REQ_MATCHED_CENTROIDS;
|
|
static const uint32_t BLOB_SET_ID = REQ_BLOB;
|
|
static const uint32_t BLOBS_SET_ID = REQ_BLOBS;
|
|
static const uint32_t CENTROID_SET_ID = REQ_CENTROID;
|
|
static const uint32_t CENTROIDS_SET_ID = REQ_CENTROIDS;
|
|
static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST;
|
|
|
|
/** Max size of unencoded frame */
|
|
static const size_t MAX_FRAME_SIZE = 1200;
|
|
|
|
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;
|
|
static const uint8_t TIME_SET_ENTRIES = 4;
|
|
static const uint8_t SOLUTION_SET_ENTRIES = 25;
|
|
static const uint8_t HISTOGRAM_SET_ENTRIES = 38;
|
|
static const uint8_t CHECKSUM_SET_ENTRIES = 1;
|
|
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 {
|
|
static const uint8_t PING = 0;
|
|
static const uint8_t BOOT = 1;
|
|
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 CENTROIDING = 11;
|
|
static const uint8_t LISA = 12;
|
|
static const uint8_t MATCHING = 13;
|
|
static const uint8_t TRACKING = 14;
|
|
static const uint8_t VALIDATION = 15;
|
|
static const uint8_t ALGO = 16;
|
|
static const uint8_t REBOOT = 7;
|
|
static const uint8_t UPLOAD_IMAGE = 10;
|
|
static const uint8_t POWER = 11;
|
|
static const uint8_t SUBSCRIPTION = 18;
|
|
static const uint8_t SOLUTION = 24;
|
|
static const uint8_t TEMPERATURE = 27;
|
|
static const uint8_t HISTOGRAM = 28;
|
|
static const uint8_t CONTRAST = 29;
|
|
static const uint8_t TIME = 1;
|
|
static const uint8_t WRITE = 2;
|
|
static const uint8_t READ = 3;
|
|
static const uint8_t CHECKSUM = 4;
|
|
static const uint8_t TAKE_IMAGE = 15;
|
|
static const uint8_t LOG_LEVEL = 3;
|
|
static const uint8_t LOG_SUBSCRIPTION = 19;
|
|
static const uint8_t DEBUG_CAMERA = 20;
|
|
static const uint8_t AUTO_THRESHOLD = 23;
|
|
static constexpr uint8_t BLOB = 25;
|
|
static constexpr uint8_t BLOBS = 36;
|
|
static constexpr uint8_t CENTROID = 26;
|
|
static constexpr uint8_t CENTROIDS = 37;
|
|
static constexpr uint8_t AUTO_BLOB = 39;
|
|
static constexpr uint8_t MATCHED_CENTROIDS = 40;
|
|
} // namespace ID
|
|
|
|
namespace Program {
|
|
static const uint8_t BOOTLOADER = 1;
|
|
static const uint8_t FIRMWARE_MAIN = 2;
|
|
static const uint8_t FIRMWARE_BACKUP = 3;
|
|
} // namespace Program
|
|
|
|
namespace region_secrets {
|
|
static const uint32_t REGION_0_SECRET = 0xd1a220d3;
|
|
static const uint32_t REGION_1_SECRET = 0xdc770fa8;
|
|
static const uint32_t REGION_2_SECRET = 0xdf9066b0;
|
|
static const uint32_t REGION_3_SECRET = 0x5f6a0423;
|
|
static const uint32_t REGION_4_SECRET = 0xbbaad5d8;
|
|
static const uint32_t REGION_5_SECRET = 0xa81c3678;
|
|
static const uint32_t REGION_6_SECRET = 0xe10f76f8;
|
|
static const uint32_t REGION_7_SECRET = 0x83220919;
|
|
static const uint32_t REGION_8_SECRET = 0xec37289d;
|
|
static const uint32_t REGION_9_SECRET = 0x27ac0ef8;
|
|
static const uint32_t REGION_10_SECRET = 0xf017e43d;
|
|
static const uint32_t REGION_11_SECRET = 0xbc7f7f49;
|
|
static const uint32_t REGION_12_SECRET = 0x42fedef6;
|
|
static const uint32_t REGION_13_SECRET = 0xe53cf10d;
|
|
static const uint32_t REGION_14_SECRET = 0xe862b70b;
|
|
static const uint32_t REGION_15_SECRET = 0x79b537ca;
|
|
static const uint32_t SECRETS[16]{
|
|
REGION_0_SECRET, REGION_1_SECRET, REGION_2_SECRET, REGION_3_SECRET,
|
|
REGION_4_SECRET, REGION_5_SECRET, REGION_6_SECRET, REGION_7_SECRET,
|
|
REGION_8_SECRET, REGION_9_SECRET, REGION_10_SECRET, REGION_11_SECRET,
|
|
REGION_12_SECRET, REGION_13_SECRET, REGION_14_SECRET, REGION_15_SECRET};
|
|
} // namespace region_secrets
|
|
|
|
namespace comError {
|
|
enum Id {
|
|
BAD_CRC = 1,
|
|
UNKNOWN_TM_ID = 2,
|
|
UNKNOWN_PARAM_ID = 3,
|
|
UNKNOWN_ACTION_REQ = 4,
|
|
INVALID_TM_SIZE = 5,
|
|
INVALID_PARAM_SIZE = 6,
|
|
INVALID_ACTION_REQ_SIZE = 7,
|
|
FRAME_TOO_SHORT = 8,
|
|
INVALID_FRAME_TYPE = 9,
|
|
UNKNOWN_ERROR = 10
|
|
};
|
|
}
|
|
|
|
enum class FlashSections : uint8_t {
|
|
BOOTLOADER_SECTION = 0,
|
|
MAIN_FIRMWARE_SECTION = 1,
|
|
ARC_CONFIG_SECTION = 2
|
|
};
|
|
|
|
// Flash region IDs of firmware partition
|
|
enum class FirmwareRegions : uint32_t {
|
|
FIRST_MAIN = 1,
|
|
LAST_MAIN = 8,
|
|
FIRST_BACKUP = 10,
|
|
LAST_BACKUP = 16
|
|
};
|
|
|
|
static const uint32_t FLASH_REGION_SIZE = 0x20000;
|
|
|
|
/**
|
|
* @brief This dataset can be used to store the temperature of a reaction wheel.
|
|
*/
|
|
class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
|
|
public:
|
|
TemperatureSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEMPERATURE_SET_ID) {}
|
|
|
|
TemperatureSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) {}
|
|
|
|
// Ticks is time reference generated by internal counter of the star tracker
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_TEMPERATURE_SET, this);
|
|
/** Unix time in microseconds */
|
|
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 (raw): " << this->cmosTemperature
|
|
<< std::endl;
|
|
sif::info << "TemperatureSet::printSet: FPGA Temperature (random value): "
|
|
<< this->fpgaTemperature << " °C" << std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Package to store version parameters
|
|
*/
|
|
class VersionSet : public StaticLocalDataSet<VERSION_SET_ENTRIES> {
|
|
public:
|
|
VersionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, VERSION_SET_ID) {}
|
|
|
|
VersionSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, VERSION_SET_ID)) {}
|
|
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_VERSION_SET, this);
|
|
/** Unix time in microseconds */
|
|
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_VERSION_SET, this);
|
|
lp_var_t<uint8_t> program = lp_var_t<uint8_t>(sid.objectId, PoolIds::PROGRAM, this);
|
|
lp_var_t<uint8_t> major = lp_var_t<uint8_t>(sid.objectId, PoolIds::MAJOR, this);
|
|
lp_var_t<uint8_t> minor = lp_var_t<uint8_t>(sid.objectId, PoolIds::MINOR, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "VersionSet::printSet: Ticks: " << std::dec << this->ticks << std::endl;
|
|
sif::info << "VersionSet::printSet: Unix Time: " << this->time << " us" << std::endl;
|
|
sif::info << "VersionSet::printSet: Program: " << static_cast<unsigned int>(this->program.value)
|
|
<< std::endl;
|
|
sif::info << "VersionSet::printSet: Major: " << static_cast<unsigned int>(this->major.value)
|
|
<< std::endl;
|
|
sif::info << "VersionSet::printSet: Minor: " << static_cast<unsigned int>(this->minor.value)
|
|
<< std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Dataset to store the interface telemtry data.
|
|
*/
|
|
class InterfaceSet : public StaticLocalDataSet<INTERFACE_SET_ENTRIES> {
|
|
public:
|
|
InterfaceSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, REQ_INTERFACE) {}
|
|
|
|
InterfaceSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, REQ_INTERFACE)) {}
|
|
|
|
// Ticks is time reference generated by interanl counter of the star tracker
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_INTERFACE_SET, this);
|
|
/** Unix time in microseconds */
|
|
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_INTERFACE_SET, this);
|
|
lp_var_t<uint32_t> frameCount = lp_var_t<uint32_t>(sid.objectId, PoolIds::FRAME_COUNT, this);
|
|
lp_var_t<uint32_t> checksumerrorCount =
|
|
lp_var_t<uint32_t>(sid.objectId, PoolIds::CHECKSUM_ERROR_COUNT, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "InterfaceSet::printSet: Ticks: " << this->ticks << std::endl;
|
|
sif::info << "InterfaceSet::printSet: Time: " << this->time << " us" << std::endl;
|
|
sif::info << "InterfaceSet::printSet: Frame Count: " << this->frameCount << std::endl;
|
|
sif::info << "InterfaceSet::printSet: Checksum Error Count: " << this->checksumerrorCount
|
|
<< std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Dataset to store the data of the power telemetry reply.
|
|
*/
|
|
class PowerSet : public StaticLocalDataSet<POWER_SET_ENTRIES> {
|
|
public:
|
|
PowerSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, REQ_INTERFACE) {}
|
|
|
|
PowerSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, REQ_INTERFACE)) {}
|
|
|
|
// Ticks is time reference generated by interanl counter of the star tracker
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_POWER_SET, this);
|
|
/** Unix time in microseconds */
|
|
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_POWER_SET, this);
|
|
lp_var_t<float> mcuCurrent = lp_var_t<float>(sid.objectId, PoolIds::MCU_CURRENT, this);
|
|
lp_var_t<float> mcuVoltage = lp_var_t<float>(sid.objectId, PoolIds::MCU_VOLTAGE, this);
|
|
lp_var_t<float> fpgaCoreCurrent = lp_var_t<float>(sid.objectId, PoolIds::FPGA_CORE_CURRENT, this);
|
|
lp_var_t<float> fpgaCoreVoltage = lp_var_t<float>(sid.objectId, PoolIds::FPGA_CORE_VOLTAGE, this);
|
|
lp_var_t<float> fpga18Current = lp_var_t<float>(sid.objectId, PoolIds::FPGA_18_CURRENT, this);
|
|
lp_var_t<float> fpga18Voltage = lp_var_t<float>(sid.objectId, PoolIds::FPGA_18_VOLTAGE, this);
|
|
lp_var_t<float> fpga25Current = lp_var_t<float>(sid.objectId, PoolIds::FPGA_25_CURRENT, this);
|
|
lp_var_t<float> fpga25Voltage = lp_var_t<float>(sid.objectId, PoolIds::FPGA_25_VOLTAGE, this);
|
|
lp_var_t<float> cmv21Current = lp_var_t<float>(sid.objectId, PoolIds::CMV_21_CURRENT, this);
|
|
lp_var_t<float> cmv21Voltage = lp_var_t<float>(sid.objectId, PoolIds::CMV_21_VOLTAGE, this);
|
|
lp_var_t<float> cmvPixCurrent = lp_var_t<float>(sid.objectId, PoolIds::CMV_PIX_CURRENT, this);
|
|
lp_var_t<float> cmvPixVoltage = lp_var_t<float>(sid.objectId, PoolIds::CMV_PIX_VOLTAGE, this);
|
|
lp_var_t<float> cmv33Current = lp_var_t<float>(sid.objectId, PoolIds::CMV_33_CURRENT, this);
|
|
lp_var_t<float> cmv33Voltage = lp_var_t<float>(sid.objectId, PoolIds::CMV_33_VOLTAGE, this);
|
|
lp_var_t<float> cmvResCurrent = lp_var_t<float>(sid.objectId, PoolIds::CMV_RES_CURRENT, this);
|
|
lp_var_t<float> cmvResVoltage = lp_var_t<float>(sid.objectId, PoolIds::CMV_RES_VOLTAGE, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "PowerSet::printSet: Ticks: " << this->ticks << std::endl;
|
|
sif::info << "PowerSet::printSet: Time: " << this->time << " us" << std::endl;
|
|
sif::info << "PowerSet::printSet: MCU Current: " << this->mcuCurrent << " A" << std::endl;
|
|
sif::info << "PowerSet::printSet: MCU Voltage: " << this->mcuVoltage << " V" << std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA Core current: " << this->fpgaCoreCurrent << " A"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA Core voltage: " << this->fpgaCoreVoltage << " V"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA 18 current: " << this->fpga18Current << " A"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA 18 voltage: " << this->fpga18Voltage << " V"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA 25 current: " << this->fpga25Current << " A"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: FPGA 25 voltage: " << this->fpga25Voltage << " V"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: CMV 21 current: " << this->cmv21Current << " A" << std::endl;
|
|
sif::info << "PowerSet::printSet: CMV 21 voltage: " << this->cmv21Voltage << " V" << std::endl;
|
|
sif::info << "PowerSet::printSet: CMV Pix current: " << this->cmvPixCurrent << " A"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: CMV Pix voltage: " << this->cmvPixVoltage << " V"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: CMV 33 current: " << this->cmv33Current << " A" << std::endl;
|
|
sif::info << "PowerSet::printSet: CMV 33 voltage: " << this->cmv33Voltage << " V" << std::endl;
|
|
sif::info << "PowerSet::printSet: CMV Res current: " << this->cmvResCurrent << " A"
|
|
<< std::endl;
|
|
sif::info << "PowerSet::printSet: CMV Res voltage: " << this->cmvResVoltage << " V"
|
|
<< std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Data set to store the time telemetry packet.
|
|
*/
|
|
class TimeSet : public StaticLocalDataSet<TIME_SET_ENTRIES> {
|
|
public:
|
|
TimeSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TIME_SET_ID) {}
|
|
|
|
TimeSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TIME_SET_ID)) {}
|
|
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_TIME_SET, this);
|
|
/** Unix time in microseconds */
|
|
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_TIME_SET, this);
|
|
// Number of milliseconds since processor start-up
|
|
lp_var_t<uint32_t> runTime = lp_var_t<uint32_t>(sid.objectId, PoolIds::RUN_TIME, this);
|
|
// Unix time in seconds?? --> maybe typo in datasheet. Seems to be microseconds
|
|
lp_var_t<uint64_t> unixTime = lp_var_t<uint64_t>(sid.objectId, PoolIds::UNIX_TIME, this);
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "TimeSet::printSet: Ticks: " << this->ticks << std::endl;
|
|
sif::info << "TimeSet::printSet: Time (time stamp): " << this->time << " us" << std::endl;
|
|
sif::info << "TimeSet::printSet: Run Time: " << this->runTime << " ms" << std::endl;
|
|
sif::info << "TimeSet::printSet: Unix Time: " << this->unixTime << " s" << std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief The solution dataset is the main dataset of the star tracker and contains the
|
|
* attitude information.
|
|
*/
|
|
class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
|
|
public:
|
|
SolutionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SOLUTION_SET_ID) {}
|
|
|
|
SolutionSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SOLUTION_SET_ID)) {}
|
|
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_SOLUTION_SET, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
|
|
// Calibrated quaternion (takes into account the mounting quaternion), typically same as
|
|
// track q values
|
|
lp_var_t<float> caliQw = lp_var_t<float>(sid.objectId, PoolIds::CALI_QW, this);
|
|
lp_var_t<float> caliQx = lp_var_t<float>(sid.objectId, PoolIds::CALI_QX, this);
|
|
lp_var_t<float> caliQy = lp_var_t<float>(sid.objectId, PoolIds::CALI_QY, this);
|
|
lp_var_t<float> caliQz = lp_var_t<float>(sid.objectId, PoolIds::CALI_QZ, this);
|
|
// The lower this value the more confidence that the star tracker solution is correct
|
|
lp_var_t<float> trackConfidence = lp_var_t<float>(sid.objectId, PoolIds::TRACK_CONFIDENCE, this);
|
|
// Estimated attitude of spacecraft
|
|
lp_var_t<float> trackQw = lp_var_t<float>(sid.objectId, PoolIds::TRACK_QW, this);
|
|
lp_var_t<float> trackQx = lp_var_t<float>(sid.objectId, PoolIds::TRACK_QX, this);
|
|
lp_var_t<float> trackQy = lp_var_t<float>(sid.objectId, PoolIds::TRACK_QY, this);
|
|
lp_var_t<float> trackQz = lp_var_t<float>(sid.objectId, PoolIds::TRACK_QZ, this);
|
|
// Number of stars removed from tracking solution
|
|
lp_var_t<uint8_t> trackRemoved = lp_var_t<uint8_t>(sid.objectId, PoolIds::TRACK_REMOVED, this);
|
|
// Number of stars for which a valid centroid was found
|
|
lp_var_t<uint8_t> starsCentroided =
|
|
lp_var_t<uint8_t>(sid.objectId, PoolIds::STARS_CENTROIDED, this);
|
|
// Number of stars that matched to a database star
|
|
lp_var_t<uint8_t> starsMatchedDatabase =
|
|
lp_var_t<uint8_t>(sid.objectId, PoolIds::STARS_MATCHED_DATABASE, this);
|
|
// Result of LISA (lost in space algorithm), searches for stars without prior knowledge of
|
|
// attitude
|
|
lp_var_t<float> lisaQw = lp_var_t<float>(sid.objectId, PoolIds::LISA_QW, this);
|
|
lp_var_t<float> lisaQx = lp_var_t<float>(sid.objectId, PoolIds::LISA_QX, this);
|
|
lp_var_t<float> lisaQy = lp_var_t<float>(sid.objectId, PoolIds::LISA_QY, this);
|
|
lp_var_t<float> lisaQz = lp_var_t<float>(sid.objectId, PoolIds::LISA_QZ, this);
|
|
// Percentage of close stars in LISA solution
|
|
lp_var_t<float> lisaPercentageClose =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LISA_PERC_CLOSE, this);
|
|
// Number of close stars in LISA solution
|
|
lp_var_t<uint8_t> lisaNrClose = lp_var_t<uint8_t>(sid.objectId, PoolIds::LISA_NR_CLOSE, this);
|
|
lp_var_t<uint8_t> strMode = lp_var_t<uint8_t>(sid.objectId, PoolIds::STR_MODE, this);
|
|
// Gives a combined overview of the validation parameters (1 for valid solution, otherwise 0)
|
|
lp_var_t<uint8_t> isTrustWorthy = lp_var_t<uint8_t>(sid.objectId, PoolIds::TRUST_WORTHY, this);
|
|
// Number of times the validation criteria was met
|
|
lp_var_t<uint32_t> stableCount = lp_var_t<uint32_t>(sid.objectId, PoolIds::STABLE_COUNT, this);
|
|
// Shows the autonomous mode used to obtain the star tracker attitude
|
|
lp_var_t<uint8_t> solutionStrategy =
|
|
lp_var_t<uint8_t>(sid.objectId, PoolIds::SOLUTION_STRATEGY, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "SolutionSet::printSet: Ticks: " << this->ticks << std::endl;
|
|
sif::info << "SolutionSet::printSet: Time: " << this->timeUs << std::endl;
|
|
sif::info << "SolutionSet::printSet: Calibrated quaternion Qw: " << this->caliQw << std::endl;
|
|
sif::info << "SolutionSet::printSet: Calibrated quaternion Qx: " << this->caliQx << std::endl;
|
|
sif::info << "SolutionSet::printSet: Calibrated quaternion Qy: " << this->caliQy << std::endl;
|
|
sif::info << "SolutionSet::printSet: Calibrated quaternion Qz: " << this->caliQz << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track confidence: " << this->trackConfidence << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track Qw: " << this->trackQw << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track Qx: " << this->trackQx << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track Qy: " << this->trackQy << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track Qz: " << this->trackQz << std::endl;
|
|
sif::info << "SolutionSet::printSet: Track removed: "
|
|
<< static_cast<unsigned int>(this->trackRemoved.value) << std::endl;
|
|
sif::info << "SolutionSet::printSet: Number of stars centroided: "
|
|
<< static_cast<unsigned int>(this->starsCentroided.value) << std::endl;
|
|
sif::info << "SolutionSet::printSet: Number of stars matched database: "
|
|
<< static_cast<unsigned int>(this->starsMatchedDatabase.value) << std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA Qw: " << this->lisaQw << std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA Qx: " << this->lisaQx << std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA Qy: " << this->lisaQy << std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA Qz: " << this->lisaQz << std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA Percentage close: " << this->lisaPercentageClose
|
|
<< std::endl;
|
|
sif::info << "SolutionSet::printSet: LISA number of close stars: "
|
|
<< static_cast<unsigned int>(this->lisaNrClose.value) << std::endl;
|
|
sif::info << "SolutionSet::printSet: Is trust worthy: "
|
|
<< static_cast<unsigned int>(this->isTrustWorthy.value) << std::endl;
|
|
sif::info << "SolutionSet::printSet: Stable count: " << this->stableCount << std::endl;
|
|
sif::info << "SolutionSet::printSet: Solution strategy: "
|
|
<< static_cast<unsigned int>(this->solutionStrategy.value) << std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Dataset to store the histogram
|
|
*/
|
|
class HistogramSet : public StaticLocalDataSet<HISTOGRAM_SET_ENTRIES> {
|
|
public:
|
|
// Size of dataset
|
|
static const size_t SIZE = 156;
|
|
|
|
HistogramSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HISTOGRAM_SET_ID) {}
|
|
|
|
HistogramSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HISTOGRAM_SET_ID)) {}
|
|
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_HISTOGRAM_SET, this);
|
|
lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_HISTOGRAM_SET, this);
|
|
lp_var_t<uint32_t> binA0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA0, this);
|
|
lp_var_t<uint32_t> binA1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA1, this);
|
|
lp_var_t<uint32_t> binA2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA2, this);
|
|
lp_var_t<uint32_t> binA3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA3, this);
|
|
lp_var_t<uint32_t> binA4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA4, this);
|
|
lp_var_t<uint32_t> binA5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA5, this);
|
|
lp_var_t<uint32_t> binA6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA6, this);
|
|
lp_var_t<uint32_t> binA7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA7, this);
|
|
lp_var_t<uint32_t> binA8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINA8, this);
|
|
lp_var_t<uint32_t> binB0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB0, this);
|
|
lp_var_t<uint32_t> binB1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB1, this);
|
|
lp_var_t<uint32_t> binB2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB2, this);
|
|
lp_var_t<uint32_t> binB3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB3, this);
|
|
lp_var_t<uint32_t> binB4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB4, this);
|
|
lp_var_t<uint32_t> binB5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB5, this);
|
|
lp_var_t<uint32_t> binB6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB6, this);
|
|
lp_var_t<uint32_t> binB7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB7, this);
|
|
lp_var_t<uint32_t> binB8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINB8, this);
|
|
lp_var_t<uint32_t> binC0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC0, this);
|
|
lp_var_t<uint32_t> binC1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC1, this);
|
|
lp_var_t<uint32_t> binC2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC2, this);
|
|
lp_var_t<uint32_t> binC3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC3, this);
|
|
lp_var_t<uint32_t> binC4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC4, this);
|
|
lp_var_t<uint32_t> binC5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC5, this);
|
|
lp_var_t<uint32_t> binC6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC6, this);
|
|
lp_var_t<uint32_t> binC7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC7, this);
|
|
lp_var_t<uint32_t> binC8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BINC8, this);
|
|
lp_var_t<uint32_t> binD0 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND0, this);
|
|
lp_var_t<uint32_t> binD1 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND1, this);
|
|
lp_var_t<uint32_t> binD2 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND2, this);
|
|
lp_var_t<uint32_t> binD3 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND3, this);
|
|
lp_var_t<uint32_t> binD4 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND4, this);
|
|
lp_var_t<uint32_t> binD5 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND5, this);
|
|
lp_var_t<uint32_t> binD6 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND6, this);
|
|
lp_var_t<uint32_t> binD7 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND7, this);
|
|
lp_var_t<uint32_t> binD8 = lp_var_t<uint32_t>(sid.objectId, PoolIds::HISTOGRAM_BIND8, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "HistogramSet::printSet: Ticks: " << this->ticks << std::endl;
|
|
sif::info << "HistogramSet::printSet: Time (time stamp): " << this->time << " us" << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA0: " << this->binA0 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA1: " << this->binA1 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA2: " << this->binA2 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA3: " << this->binA3 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA4: " << this->binA4 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA5: " << this->binA5 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA6: " << this->binA6 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA7: " << this->binA7 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinA8: " << this->binA8 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB0: " << this->binB0 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB1: " << this->binB1 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB2: " << this->binB2 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB3: " << this->binB3 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB4: " << this->binB4 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB5: " << this->binB5 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB6: " << this->binB6 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB7: " << this->binB7 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinB8: " << this->binB8 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC0: " << this->binC0 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC1: " << this->binC1 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC2: " << this->binC2 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC3: " << this->binC3 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC4: " << this->binC4 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC5: " << this->binC5 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC6: " << this->binC6 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC7: " << this->binC7 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinC8: " << this->binC8 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD0: " << this->binD0 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD1: " << this->binD1 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD2: " << this->binD2 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD3: " << this->binD3 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD4: " << this->binD4 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD5: " << this->binD5 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD6: " << this->binD6 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD7: " << this->binD7 << std::endl;
|
|
sif::info << "HistogramSet::printSet: BinD8: " << this->binD8 << std::endl;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Helper Class to extract information from bytestream.
|
|
*/
|
|
class ChecksumReply {
|
|
public:
|
|
/**
|
|
* @brief Constructor
|
|
*
|
|
* @param datafield Pointer to datafield in reply buffer
|
|
*
|
|
*/
|
|
ChecksumReply(const uint8_t* datafield) {
|
|
ReturnValue_t result = returnvalue::OK;
|
|
region = *(datafield);
|
|
const uint8_t* addressData = datafield + ADDRESS_OFFSET;
|
|
size_t size = sizeof(address);
|
|
result = SerializeAdapter::deSerialize(&address, &addressData, &size,
|
|
SerializeIF::Endianness::LITTLE);
|
|
if (result != returnvalue::OK) {
|
|
sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize address" << std::endl;
|
|
}
|
|
const uint8_t* lengthData = datafield + LENGTH_OFFSET;
|
|
size = sizeof(length);
|
|
result =
|
|
SerializeAdapter::deSerialize(&length, &lengthData, &size, SerializeIF::Endianness::LITTLE);
|
|
if (result != returnvalue::OK) {
|
|
sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize length" << std::endl;
|
|
}
|
|
const uint8_t* checksumData = datafield + CHECKSUM_OFFSET;
|
|
size = sizeof(checksum);
|
|
result = SerializeAdapter::deSerialize(&checksum, &checksumData, &size,
|
|
SerializeIF::Endianness::LITTLE);
|
|
if (result != returnvalue::OK) {
|
|
sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize checksum" << std::endl;
|
|
}
|
|
}
|
|
|
|
uint8_t getRegion() { return region; }
|
|
|
|
uint32_t getAddress() { return address; }
|
|
|
|
uint32_t getLength() { return length; }
|
|
|
|
uint32_t getChecksum() { return checksum; }
|
|
|
|
void printChecksum() {
|
|
sif::info << "ChecksumReply::printChecksum: 0x" << std::hex << checksum << std::endl;
|
|
}
|
|
|
|
private:
|
|
static const uint8_t ADDRESS_OFFSET = 1;
|
|
static const uint8_t LENGTH_OFFSET = 5;
|
|
static const uint8_t CHECKSUM_OFFSET = 9;
|
|
|
|
uint8_t region = 0;
|
|
uint32_t address = 0;
|
|
uint32_t length = 0;
|
|
uint32_t checksum = 0;
|
|
};
|
|
|
|
class ChecksumSet : public StaticLocalDataSet<CHECKSUM_SET_ENTRIES> {
|
|
public:
|
|
// Size of dataset
|
|
static const size_t SIZE = 156;
|
|
|
|
ChecksumSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CHECKSUM_SET_ID) {}
|
|
|
|
ChecksumSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, CHECKSUM_SET_ID)) {}
|
|
|
|
lp_var_t<uint32_t> checksum = lp_var_t<uint32_t>(sid.objectId, PoolIds::CHKSUM, this);
|
|
};
|
|
|
|
/**
|
|
* @brief Will store the camera parameters set in the star tracker which are retrieved with
|
|
* a get parameter request.
|
|
*/
|
|
class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
|
|
public:
|
|
// Size of dataset
|
|
static const size_t SIZE = 34;
|
|
|
|
CameraSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CAMERA_SET_ID) {}
|
|
|
|
CameraSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, CAMERA_SET_ID)) {}
|
|
|
|
lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAMERA_MODE, this);
|
|
lp_var_t<float> focallength = lp_var_t<float>(sid.objectId, PoolIds::FOCALLENGTH, this);
|
|
lp_var_t<float> exposure = lp_var_t<float>(sid.objectId, PoolIds::EXPOSURE, this);
|
|
lp_var_t<float> interval = lp_var_t<float>(sid.objectId, PoolIds::INTERVAL, this);
|
|
lp_var_t<int16_t> offset = lp_var_t<int16_t>(sid.objectId, PoolIds::CAMERA_OFFSET, this);
|
|
lp_var_t<uint8_t> pgagain = lp_var_t<uint8_t>(sid.objectId, PoolIds::PGAGAIN, this);
|
|
lp_var_t<uint8_t> adcgain = lp_var_t<uint8_t>(sid.objectId, PoolIds::ADCGAIN, this);
|
|
lp_var_t<uint8_t> reg1 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG1, this);
|
|
lp_var_t<uint8_t> val1 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL1, this);
|
|
lp_var_t<uint8_t> reg2 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG2, this);
|
|
lp_var_t<uint8_t> val2 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_VAL2, this);
|
|
lp_var_t<uint8_t> reg3 = lp_var_t<uint8_t>(sid.objectId, PoolIds::CAM_REG3, this);
|
|
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);
|
|
sif::info << "CameraSet::printSet: mode: " << static_cast<unsigned int>(this->mode.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: focallength: " << this->focallength << std::endl;
|
|
sif::info << "CameraSet::printSet: exposure: " << this->exposure << std::endl;
|
|
sif::info << "CameraSet::printSet: interval: " << this->interval << std::endl;
|
|
sif::info << "CameraSet::printSet: offset: " << this->offset << std::endl;
|
|
sif::info << "CameraSet::printSet: PGA gain: " << static_cast<unsigned int>(this->pgagain.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: ADC gain: " << static_cast<unsigned int>(this->adcgain.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Reg 1: " << static_cast<unsigned int>(this->reg1.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Val 1: " << static_cast<unsigned int>(this->val1.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Reg 2: " << static_cast<unsigned int>(this->reg2.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Val 2: " << static_cast<unsigned int>(this->val2.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Reg 3: " << static_cast<unsigned int>(this->reg3.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Val 3: " << static_cast<unsigned int>(this->val3.value)
|
|
<< std::endl;
|
|
sif::info << "CameraSet::printSet: Reg 4: " << static_cast<unsigned int>(this->reg4.value)
|
|
<< 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;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief Will store the requested limits
|
|
*/
|
|
class LimitsSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
|
|
public:
|
|
// Size of dataset
|
|
static const size_t SIZE = 41;
|
|
|
|
LimitsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LIMITS_SET_ID) {}
|
|
|
|
LimitsSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LIMITS_SET_ID)) {}
|
|
|
|
lp_var_t<uint8_t> action = lp_var_t<uint8_t>(sid.objectId, PoolIds::LIMITS_ACTION, this);
|
|
lp_var_t<float> fpga18current =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA18CURRENT, this);
|
|
lp_var_t<float> fpga25current =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA25CURRENT, this);
|
|
lp_var_t<float> fpga10current =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_FPGA10CURRENT, this);
|
|
lp_var_t<float> mcuCurrent = lp_var_t<float>(sid.objectId, PoolIds::LIMITS_MCUCURRENT, this);
|
|
lp_var_t<float> cmos21current =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOS21CURRENT, this);
|
|
lp_var_t<float> cmosPixCurrent =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSPIXCURRENT, this);
|
|
lp_var_t<float> cmos33current =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOS33CURRENT, this);
|
|
lp_var_t<float> cmosVresCurrent =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSVRESCURRENT, this);
|
|
lp_var_t<float> cmosTemperature =
|
|
lp_var_t<float>(sid.objectId, PoolIds::LIMITS_CMOSTEMPERATURE, this);
|
|
|
|
void printSet() {
|
|
PoolReadGuard rg(this);
|
|
sif::info << "LimitsSet::printSet: action: " << static_cast<unsigned int>(this->action.value)
|
|
<< 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<LOG_LEVEL_SET_ENTRIES> {
|
|
public:
|
|
// Size of dataset
|
|
static const size_t SIZE = 16;
|
|
|
|
LogLevelSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOG_LEVEL_SET_ID) {}
|
|
|
|
LogLevelSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOG_LEVEL_SET_ID)) {}
|
|
|
|
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: "
|
|
<< static_cast<unsigned int>(this->mode.value) << std::endl;
|
|
sif::info << "ImageProcessorSet::printSet: store: "
|
|
<< static_cast<unsigned int>(this->store.value) << 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: "
|
|
<< static_cast<unsigned int>(this->backgroundCompensation.value) << 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: "
|
|
<< static_cast<unsigned int>(this->enableFilter.value) << 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: "
|
|
<< static_cast<unsigned int>(this->maxCombinations.value) << std::endl;
|
|
sif::info << "LisaSet::printSet: nr stars stop: "
|
|
<< static_cast<unsigned int>(this->nrStarsStop.value) << 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 = 13;
|
|
|
|
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<uint8_t> trackerChoice =
|
|
lp_var_t<uint8_t>(sid.objectId, PoolIds::TRACKING_TRACKER_CHOICE, this);
|
|
|
|
void printSet() {
|
|
sif::info << "TrackingSet::printSet: thin limit: " << this->thinLimit << std::endl;
|
|
sif::info << "TrackingSet::printSet: outlier threshold: " << this->outlierThreshold
|
|
<< std::endl;
|
|
sif::info << "TrackingSet::printSet: outlier threshold quest: " << this->outlierThresholdQuest
|
|
<< std::endl;
|
|
sif::info << "TrackingSet::printSet: tracker choice: "
|
|
<< static_cast<unsigned int>(this->trackerChoice.value) << 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.value) << 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: "
|
|
<< static_cast<unsigned int>(this->minMatchedStars.value) << std::endl;
|
|
}
|
|
};
|
|
|
|
class AutoBlobSet : public StaticLocalDataSet<3> {
|
|
public:
|
|
AutoBlobSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, AUTO_BLOB_SET_ID) {}
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_AUTO_BLOB, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_AUTO_BLOB, this);
|
|
lp_var_t<float> threshold = lp_var_t<float>(sid.objectId, PoolIds::AUTO_BLOB_THRESHOLD, this);
|
|
|
|
private:
|
|
};
|
|
|
|
class MatchedCentroidsSet : public StaticLocalDataSet<20> {
|
|
public:
|
|
MatchedCentroidsSet(HasLocalDataPoolIF* owner)
|
|
: StaticLocalDataSet(owner, MATCHED_CENTROIDS_SET_ID) {}
|
|
MatchedCentroidsSet(object_id_t objectId)
|
|
: StaticLocalDataSet(sid_t(objectId, MATCHED_CENTROIDS_SET_ID)) {}
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks =
|
|
lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_MATCHED_CENTROIDS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs =
|
|
lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_MATCHED_CENTROIDS, this);
|
|
lp_var_t<uint8_t> numberOfMatchedCentroids =
|
|
lp_var_t<uint8_t>(sid.objectId, PoolIds::NUM_MATCHED_CENTROIDS, this);
|
|
lp_vec_t<uint32_t, 16> starIds =
|
|
lp_vec_t<uint32_t, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_STAR_IDS, this);
|
|
lp_vec_t<float, 16> xCoords =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_X_COORDS, this);
|
|
lp_vec_t<float, 16> yCoords =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_Y_COORDS, this);
|
|
lp_vec_t<float, 16> xErrors =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_X_ERRORS, this);
|
|
lp_vec_t<float, 16> yErrors =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_Y_ERRORS, this);
|
|
|
|
private:
|
|
};
|
|
|
|
class BlobSet : public StaticLocalDataSet<5> {
|
|
public:
|
|
BlobSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOB_SET_ID) {}
|
|
// The blob count received from the Blob Telemetry Set (ID 25)
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_TICKS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::BLOB_TIME, this);
|
|
lp_var_t<uint32_t> blobCount = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_COUNT, this);
|
|
};
|
|
|
|
class BlobsSet : public StaticLocalDataSet<10> {
|
|
public:
|
|
BlobsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOBS_SET_ID) {}
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBS_TICKS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::BLOBS_TIME, this);
|
|
lp_var_t<uint16_t> blobsCount = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_COUNT, this);
|
|
lp_var_t<uint16_t> blobsCountUsed =
|
|
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_COUNT_USED, this);
|
|
lp_var_t<uint16_t> nr4LinesSkipped =
|
|
lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_NR_4LINES_SKIPPED, this);
|
|
lp_vec_t<uint16_t, 8> xCoords =
|
|
lp_vec_t<uint16_t, 8>(sid.objectId, PoolIds::BLOBS_X_COORDS, this);
|
|
lp_vec_t<uint16_t, 8> yCoords =
|
|
lp_vec_t<uint16_t, 8>(sid.objectId, PoolIds::BLOBS_Y_COORDS, this);
|
|
};
|
|
|
|
class CentroidSet : public StaticLocalDataSet<5> {
|
|
public:
|
|
CentroidSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CENTROID_SET_ID) {}
|
|
|
|
// Data received from the Centroid Telemetry Set (ID 26)
|
|
// Ticks timestamp
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROID_TICKS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::CENTROID_TIME, this);
|
|
// The centroid count received from the Centroid Telemetry Set (ID 26)
|
|
lp_var_t<uint32_t> centroidCount =
|
|
lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROID_COUNT, this);
|
|
};
|
|
|
|
class CentroidsSet : public StaticLocalDataSet<10> {
|
|
public:
|
|
CentroidsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CENTROIDS_SET_ID) {}
|
|
|
|
// Data received from the Centroids Telemetry Set (ID 37)
|
|
lp_var_t<uint32_t> ticksCentroidsTm =
|
|
lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROIDS_TICKS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUsCentroidsTm =
|
|
lp_var_t<uint64_t>(sid.objectId, PoolIds::CENTROIDS_TIME, this);
|
|
lp_var_t<uint16_t> centroidsCount =
|
|
lp_var_t<uint16_t>(sid.objectId, PoolIds::CENTROIDS_COUNT, this);
|
|
lp_vec_t<float, 16> centroidsXCoords =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::CENTROIDS_X_COORDS, this);
|
|
lp_vec_t<float, 16> centroidsYCoords =
|
|
lp_vec_t<float, 16>(sid.objectId, PoolIds::CENTROIDS_Y_COORDS, this);
|
|
lp_vec_t<uint8_t, 16> centroidsMagnitudes =
|
|
lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::CENTROIDS_MAGNITUDES, this);
|
|
};
|
|
|
|
class ContrastSet : public StaticLocalDataSet<8> {
|
|
public:
|
|
ContrastSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CONTRAST_SET_ID) {}
|
|
|
|
// Data received from the Centroids Telemetry Set (ID 29)
|
|
lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_TICKS, this);
|
|
// Unix time stamp
|
|
lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::CONTRAST_TIME, this);
|
|
lp_vec_t<uint32_t, 9> contrastA = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_A, this);
|
|
lp_vec_t<uint32_t, 9> contrastB = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_B, this);
|
|
lp_vec_t<uint32_t, 9> contrastC = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_C, this);
|
|
lp_vec_t<uint32_t, 9> contrastD = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_D, this);
|
|
};
|
|
|
|
/**
|
|
* @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.value)
|
|
<< 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.value) << 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.value) << 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.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 2: "
|
|
<< static_cast<unsigned int>(this->tm2.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 3: "
|
|
<< static_cast<unsigned int>(this->tm3.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 4: "
|
|
<< static_cast<unsigned int>(this->tm4.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 5: "
|
|
<< static_cast<unsigned int>(this->tm5.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 6: "
|
|
<< static_cast<unsigned int>(this->tm6.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 7: "
|
|
<< static_cast<unsigned int>(this->tm7.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 8: "
|
|
<< static_cast<unsigned int>(this->tm8.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 9: "
|
|
<< static_cast<unsigned int>(this->tm9.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 10: "
|
|
<< static_cast<unsigned int>(this->tm10.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 11: "
|
|
<< static_cast<unsigned int>(this->tm11.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 12: "
|
|
<< static_cast<unsigned int>(this->tm12.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 13: "
|
|
<< static_cast<unsigned int>(this->tm13.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 14: "
|
|
<< static_cast<unsigned int>(this->tm14.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 15: "
|
|
<< static_cast<unsigned int>(this->tm15.value) << std::endl;
|
|
sif::info << "SubscriptionSet::printSet: telemetry 16: "
|
|
<< static_cast<unsigned int>(this->tm16.value) << 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.value) << std::endl;
|
|
sif::info << "LogSubscriptionSet::printSet: module 1: "
|
|
<< static_cast<unsigned int>(this->module1.value) << std::endl;
|
|
sif::info << "LogSubscriptionSet::printSet: level 2: "
|
|
<< static_cast<unsigned int>(this->level2.value) << std::endl;
|
|
sif::info << "LogSubscriptionSet::printSet: module 2: "
|
|
<< static_cast<unsigned int>(this->module2.value) << 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: timing: " << this->timing << std::endl;
|
|
sif::info << "DebugCameraSet::printSet: test: " << this->test << std::endl;
|
|
}
|
|
};
|
|
} // namespace startracker
|
|
#endif /* LINUX_DEVICES_DEVICEDEFINITIONS_STARTRACKER_DEFINITIONS_H_ */
|