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

fixed conflicts

Browse Source
This commit is contained in:
Jakob Meier 2022-02-11 15:09:45 +01:00
commit 685b9cd1fb
11 changed files with 2125 additions and 582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
README.md
View File

@ -19,9 +19,10 @@
12. [Static Code Analysis](#static-code-analysis) 12. [Static Code Analysis](#static-code-analysis)
13. [Eclipse](#eclipse) 13. [Eclipse](#eclipse)
14. [Running the OBSW on a Raspberry Pi](#rpi) 14. [Running the OBSW on a Raspberry Pi](#rpi)
15. [Manually preparing sysroots to compile gpsd](#gpsd) 15. [Running OBSW on EGSE](#egse)
16. [FSFW](#fsfw) 16. [Manually preparing sysroots to compile gpsd](#gpsd)
17. [Coding Style](#coding-style) 17. [FSFW](#fsfw)
18. [Coding Style](#coding-style)
# <a id="general"></a> General information # <a id="general"></a> General information
@ -1134,6 +1135,33 @@ sudo apt-get install gpiod libgpiod-dev
to install the required GPIO libraries before cloning the system root folder. to install the required GPIO libraries before cloning the system root folder.
# <a id="egse"></a> Running OBSW on EGSE
The EGSE is a test system from arcsec build arround a raspberry pi 4 to test the star tracker. The IP address of the EGSE (raspberry pi) is 192.168.18.31. An ssh session can be opened with
````
ssh pi@192.168.18.31
````
Password: raspberry
To run the obsw perform the following steps:
1. Build the cmake EGSE Configuration
* the sysroots for the EGSE can be found [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/egse&fileid=1190471)
2. Disable the ser2net systemd service on the EGSE
````sh
$ sudo systemctl stop ser2net.service
````
3. Power on the star tracker by running
````sh
$ ~/powerctrl/enable0.sh`
````
4. Run portforwarding script for tmtc tcp connection and tcf agent on host PC
````sh
$ ./scripts/egse-port.sh
````
5. The star tracker can be powered off by running
````sh
$ ~/powerctrl/disable0.sh
````
# <a id="gpsd"></a> Manually preparing sysroots to compile gpsd # <a id="gpsd"></a> Manually preparing sysroots to compile gpsd
Copy all header files from [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/gpsd&fileid=1189985) to the /usr/include directory and all static libraries to /usr/lib. Copy all header files from [here](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/gpsd&fileid=1189985) to the /usr/include directory and all static libraries to /usr/lib.

4
bsp_egse/InitMission.cpp
View File

@ -24,6 +24,10 @@ ServiceInterfaceStream sif::error("ERROR");
ObjectManagerIF* objectManager = nullptr; ObjectManagerIF* objectManager = nullptr;
void initmission::initMission() { void initmission::initMission() {
sif::info << "Make sure the systemd service ser2net on the egse has been stopped "
<< "(alias stop-ser2net)" << std::endl;
sif::info << "Make sure the power lines of the star tracker have been enabled "
<< "(alias enable-startracker)" << std::endl;
sif::info << "Building global objects.." << std::endl; sif::info << "Building global objects.." << std::endl;
/* Instantiate global object manager and also create all objects */ /* Instantiate global object manager and also create all objects */
ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr); ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);

689
linux/devices/devicedefinitions/StarTrackerDefinitions.h
View File

@ -214,6 +214,15 @@ enum PoolIds : lp_id_t {
CAM_VAL3, CAM_VAL3,
CAM_REG4, CAM_REG4,
CAM_VAL4, CAM_VAL4,
CAM_REG5,
CAM_VAL5,
CAM_REG6,
CAM_VAL6,
CAM_REG7,
CAM_VAL7,
CAM_REG8,
CAM_VAL8,
CAM_FREQ_1,
LIMITS_ACTION, LIMITS_ACTION,
LIMITS_FPGA18CURRENT, LIMITS_FPGA18CURRENT,
LIMITS_FPGA25CURRENT, LIMITS_FPGA25CURRENT,
@ -239,7 +248,96 @@ enum PoolIds : lp_id_t {
BLOB_DARK_THRESHOLD, BLOB_DARK_THRESHOLD,
BLOB_ENABLE_HISTOGRAM, BLOB_ENABLE_HISTOGRAM,
BLOB_ENABLE_CONTRAST, 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; static const DeviceCommandId_t PING_REQUEST = 0;
@ -257,7 +355,7 @@ static const DeviceCommandId_t REQ_POWER = 11;
static const DeviceCommandId_t TAKE_IMAGE = 15; static const DeviceCommandId_t TAKE_IMAGE = 15;
static const DeviceCommandId_t DOWNLOAD_CENTROID = 16; static const DeviceCommandId_t DOWNLOAD_CENTROID = 16;
static const DeviceCommandId_t UPLOAD_CENTROID = 17; static const DeviceCommandId_t UPLOAD_CENTROID = 17;
static const DeviceCommandId_t SUBSCRIBE_TO_TM = 18; static const DeviceCommandId_t SUBSCRIPTION = 18;
static const DeviceCommandId_t IMAGE_PROCESSOR = 19; static const DeviceCommandId_t IMAGE_PROCESSOR = 19;
static const DeviceCommandId_t REQ_SOLUTION = 24; static const DeviceCommandId_t REQ_SOLUTION = 24;
static const DeviceCommandId_t REQ_TEMPERATURE = 25; static const DeviceCommandId_t REQ_TEMPERATURE = 25;
@ -290,6 +388,21 @@ static const DeviceCommandId_t UPLOAD_FPGA_IMAGE = 65;
static const DeviceCommandId_t FPGA_ACTION = 66; static const DeviceCommandId_t FPGA_ACTION = 66;
static const DeviceCommandId_t REQ_CAMERA = 67; static const DeviceCommandId_t REQ_CAMERA = 67;
static const DeviceCommandId_t REQ_LIMITS = 68; static const DeviceCommandId_t REQ_LIMITS = 68;
static const DeviceCommandId_t REQ_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 NONE = 0xFFFFFFFF; static const DeviceCommandId_t NONE = 0xFFFFFFFF;
static const uint32_t VERSION_SET_ID = REQ_VERSION; static const uint32_t VERSION_SET_ID = REQ_VERSION;
@ -307,6 +420,18 @@ static const uint32_t DOWNLOAD_DBIMAGE_SET_ID = DOWNLOAD_DBIMAGE;
static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL; static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL;
static const uint32_t CAMERA_SET_ID = REQ_CAMERA; static const uint32_t CAMERA_SET_ID = REQ_CAMERA;
static const uint32_t LIMITS_SET_ID = REQ_LIMITS; static const uint32_t LIMITS_SET_ID = REQ_LIMITS;
static const uint32_t 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;
/** Max size of unencoded frame */ /** Max size of unencoded frame */
static const size_t MAX_FRAME_SIZE = 1200; static const size_t MAX_FRAME_SIZE = 1200;
@ -324,8 +449,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_MATCHED_STAR_SET_ENTRIES = 14;
static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6; static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6;
static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7; static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7;
static const uint8_t CAMERA_SET_ENTRIES = 15; static const uint8_t CAMERA_SET_ENTRIES = 24;
static const uint8_t LIMITS_SET_ENTRIES = 11; 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 // Action, parameter and telemetry IDs
namespace ID { namespace ID {
@ -347,7 +484,7 @@ static const uint8_t REBOOT = 7;
static const uint8_t UPLOAD_IMAGE = 10; static const uint8_t UPLOAD_IMAGE = 10;
static const uint8_t POWER = 11; static const uint8_t POWER = 11;
static const uint8_t SET_TIME = 14; static const uint8_t SET_TIME = 14;
static const uint8_t SUBSCRIBE = 18; static const uint8_t SUBSCRIPTION = 18;
static const uint8_t SOLUTION = 24; static const uint8_t SOLUTION = 24;
static const uint8_t TEMPERATURE = 27; static const uint8_t TEMPERATURE = 27;
static const uint8_t HISTOGRAM = 28; static const uint8_t HISTOGRAM = 28;
@ -366,6 +503,9 @@ static const uint8_t DOWNLOAD_MATCHED_STAR = 18;
static const uint8_t DOWNLOAD_DBIMAGE = 19; static const uint8_t DOWNLOAD_DBIMAGE = 19;
static const uint8_t DOWNLOAD_BLOBPIXEL = 24; static const uint8_t DOWNLOAD_BLOBPIXEL = 24;
static const uint8_t FPGA_ACTION = 22; 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 ID
namespace Program { namespace Program {
@ -1153,7 +1293,7 @@ class DownloadBlobPixel : public StaticLocalDataSet<DOWNLOAD_BLOBPIXEL_SET_ENTRI
class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> { class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
public: public:
// Size of dataset // Size of dataset
static const size_t SIZE = 25; static const size_t SIZE = 34;
CameraSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CAMERA_SET_ID) {} CameraSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CAMERA_SET_ID) {}
@ -1174,6 +1314,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> 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> 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> 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() { void printSet() {
PoolReadGuard rg(this); PoolReadGuard rg(this);
@ -1203,6 +1352,24 @@ class CameraSet : public StaticLocalDataSet<CAMERA_SET_ENTRIES> {
<< std::endl; << std::endl;
sif::info << "CameraSet::printSet: Val 4: " << static_cast<unsigned int>(this->val4.value) sif::info << "CameraSet::printSet: Val 4: " << static_cast<unsigned int>(this->val4.value)
<< std::endl; << 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;
} }
}; };
@ -1239,17 +1406,509 @@ class LimitsSet : public StaticLocalDataSet<LIMITS_SET_ENTRIES> {
void printSet() { void printSet() {
PoolReadGuard rg(this); 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; << std::endl;
sif::info << "CameraSet::printSet: FPGA18Current: " << this->fpga18current << std::endl; sif::info << "LimitsSet::printSet: FPGA18Current: " << this->fpga18current << std::endl;
sif::info << "CameraSet::printSet: FPGA25Current: " << this->fpga25current << std::endl; sif::info << "LimitsSet::printSet: FPGA25Current: " << this->fpga25current << std::endl;
sif::info << "CameraSet::printSet: FPGA10Current: " << this->fpga10current << std::endl; sif::info << "LimitsSet::printSet: FPGA10Current: " << this->fpga10current << std::endl;
sif::info << "CameraSet::printSet: MCUCurrent: " << this->mcuCurrent << std::endl; sif::info << "LimitsSet::printSet: MCUCurrent: " << this->mcuCurrent << std::endl;
sif::info << "CameraSet::printSet: CMOS21Current: " << this->cmos21current << std::endl; sif::info << "LimitsSet::printSet: CMOS21Current: " << this->cmos21current << std::endl;
sif::info << "CameraSet::printSet: CMOSPixCurrent: " << this->cmosPixCurrent << std::endl; sif::info << "LimitsSet::printSet: CMOSPixCurrent: " << this->cmosPixCurrent << std::endl;
sif::info << "CameraSet::printSet: CMOS33Current: " << this->cmos33current << std::endl; sif::info << "LimitsSet::printSet: CMOS33Current: " << this->cmos33current << std::endl;
sif::info << "CameraSet::printSet: CMOSVResCurrent: " << this->cmosVresCurrent << std::endl; sif::info << "LimitsSet::printSet: CMOSVResCurrent: " << this->cmosVresCurrent << std::endl;
sif::info << "CameraSet::printSet: CMOSTemperature: " << this->cmosTemperature << 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;
}
};
/**
* @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 } // namespace StarTracker

49
linux/devices/startracker/ArcsecJsonKeys.h
View File

@ -126,9 +126,56 @@ static const char TRACKER_CHOICE[] = "trackerChoice";
static const char ALGO[] = "algo"; static const char ALGO[] = "algo";
static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence"; static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence";
static const char L2T_MIN_MATCHED[] = "l2t_minConfidence"; static const char L2T_MIN_MATCHED[] = "l2t_minMatched";
static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence"; static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence";
static const char T2L_MIN_MATCHED[] = "t2l_minMatched"; static const char T2L_MIN_MATCHED[] = "t2l_minMatched";
static const char LOGLEVEL[] = "loglevel";
static const char LOGLEVEL1[] = "loglevel1";
static const char LOGLEVEL2[] = "loglevel2";
static const char LOGLEVEL3[] = "loglevel3";
static const char LOGLEVEL4[] = "loglevel4";
static const char LOGLEVEL5[] = "loglevel5";
static const char LOGLEVEL6[] = "loglevel6";
static const char LOGLEVEL7[] = "loglevel7";
static const char LOGLEVEL8[] = "loglevel8";
static const char LOGLEVEL9[] = "loglevel9";
static const char LOGLEVEL10[] = "loglevel10";
static const char LOGLEVEL11[] = "loglevel11";
static const char LOGLEVEL12[] = "loglevel12";
static const char LOGLEVEL13[] = "loglevel13";
static const char LOGLEVEL14[] = "loglevel14";
static const char LOGLEVEL15[] = "loglevel15";
static const char LOGLEVEL16[] = "loglevel16";
static const char SUBSCRIPTION[] = "subscription";
static const char TELEMETRY_1[] = "telemetry1";
static const char TELEMETRY_2[] = "telemetry2";
static const char TELEMETRY_3[] = "telemetry3";
static const char TELEMETRY_4[] = "telemetry4";
static const char TELEMETRY_5[] = "telemetry5";
static const char TELEMETRY_6[] = "telemetry6";
static const char TELEMETRY_7[] = "telemetry7";
static const char TELEMETRY_8[] = "telemetry8";
static const char TELEMETRY_9[] = "telemetry9";
static const char TELEMETRY_10[] = "telemetry10";
static const char TELEMETRY_11[] = "telemetry11";
static const char TELEMETRY_12[] = "telemetry12";
static const char TELEMETRY_13[] = "telemetry13";
static const char TELEMETRY_14[] = "telemetry14";
static const char TELEMETRY_15[] = "telemetry15";
static const char TELEMETRY_16[] = "telemetry16";
static const char LOG_SUBSCRIPTION[] = "logsubscription";
static const char LEVEL1[] = "level1";
static const char MODULE1[] = "module1";
static const char LEVEL2[] = "level2";
static const char MODULE2[] = "module2";
static const char DEBUG_CAMERA[] = "debugcamera";
static const char TIMING[] = "timing";
static const char TEST[] = "test";
} // namespace arcseckeys } // namespace arcseckeys
#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */ #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */

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

File diff suppressed because it is too large Load Diff

69
linux/devices/startracker/StarTrackerHandler.h
View File

@ -1,6 +1,7 @@
#ifndef MISSION_DEVICES_STARTRACKERHANDLER_H_ #ifndef MISSION_DEVICES_STARTRACKERHANDLER_H_
#define MISSION_DEVICES_STARTRACKERHANDLER_H_ #define MISSION_DEVICES_STARTRACKERHANDLER_H_
#include "OBSWConfig.h"
#include <fsfw/datapool/PoolReadGuard.h> #include <fsfw/datapool/PoolReadGuard.h>
#include "ArcsecDatalinkLayer.h" #include "ArcsecDatalinkLayer.h"
@ -245,21 +246,33 @@ class StarTrackerHandler : public DeviceHandlerBase {
ArcsecDatalinkLayer dataLinkLayer; ArcsecDatalinkLayer dataLinkLayer;
startracker::TemperatureSet temperatureSet; StarTracker::TemperatureSet temperatureSet;
startracker::VersionSet versionSet; StarTracker::VersionSet versionSet;
startracker::PowerSet powerSet; StarTracker::PowerSet powerSet;
startracker::InterfaceSet interfaceSet; StarTracker::InterfaceSet interfaceSet;
startracker::TimeSet timeSet; StarTracker::TimeSet timeSet;
startracker::SolutionSet solutionSet; StarTracker::SolutionSet solutionSet;
startracker::HistogramSet histogramSet; StarTracker::HistogramSet histogramSet;
startracker::ContrastSet contrastSet; StarTracker::ContrastSet contrastSet;
startracker::ChecksumSet checksumSet; StarTracker::ChecksumSet checksumSet;
startracker::DownloadCentroidSet downloadCentroidSet; StarTracker::DownloadCentroidSet downloadCentroidSet;
startracker::DownloadMatchedStar downloadMatchedStar; StarTracker::DownloadMatchedStar downloadMatchedStar;
startracker::DownloadDBImage downloadDbImage; StarTracker::DownloadDBImage downloadDbImage;
startracker::DownloadBlobPixel downloadBlobPixel; StarTracker::DownloadBlobPixel downloadBlobPixel;
startracker::CameraSet cameraSet; StarTracker::CameraSet cameraSet;
startracker::LimitsSet limitsSet; StarTracker::LimitsSet limitsSet;
StarTracker::LogLevelSet loglevelSet;
StarTracker::MountingSet mountingSet;
StarTracker::ImageProcessorSet imageProcessorSet;
StarTracker::CentroidingSet centroidingSet;
StarTracker::LisaSet lisaSet;
StarTracker::MatchingSet matchingSet;
StarTracker::TrackingSet trackingSet;
StarTracker::ValidationSet validationSet;
StarTracker::AlgoSet algoSet;
StarTracker::SubscriptionSet subscriptionSet;
StarTracker::LogSubscriptionSet logSubscriptionSet;
StarTracker::DebugCameraSet debugCameraSet;
// Pointer to object responsible for uploading and downloading images to/from the star tracker // Pointer to object responsible for uploading and downloading images to/from the star tracker
StrHelper* strHelper = nullptr; StrHelper* strHelper = nullptr;
@ -269,8 +282,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
// Countdown to insert delay for star tracker to switch from bootloader to firmware program // Countdown to insert delay for star tracker to switch from bootloader to firmware program
Countdown bootCountdown; Countdown bootCountdown;
#ifdef EGSE #ifndef EGSE
std::string paramJsonFile = "/mnt/sd0/startracker/full.json"; std::string paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
#else #else
#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1 #if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
std::string paramJsonFile = "/mnt/sd0/startracker/ground-config.json"; std::string paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
@ -288,6 +301,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
CHECK_BOOT_STATE, CHECK_BOOT_STATE,
BOOT, BOOT,
BOOT_DELAY, BOOT_DELAY,
LOGLEVEL,
LIMITS, LIMITS,
TRACKING, TRACKING,
MOUNTING, MOUNTING,
@ -299,6 +313,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
MATCHING, MATCHING,
VALIDATION, VALIDATION,
ALGO, ALGO,
LOG_SUBSCRIPTION,
DEBUG_CAMERA,
WAIT_FOR_EXECUTION, WAIT_FOR_EXECUTION,
DONE DONE
}; };
@ -499,14 +515,23 @@ class StarTrackerHandler : public DeviceHandlerBase {
ReturnValue_t prepareFpgaActionCommand(const uint8_t* commandData, size_t commandDataLen); 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(); ReturnValue_t prepareRequestCameraParams();
/**
* @brief Will fill the command buffer with the command to request the set limits.
*/
ReturnValue_t prepareRequestLimitsParams(); 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. * @brief Handles action replies with datasets.

283
linux/devices/startracker/StarTrackerJsonCommands.cpp
View File

@ -504,6 +504,12 @@ ReturnValue_t Lisa::createCommand(uint8_t* buffer) {
} }
addfloat(param, buffer + offset); addfloat(param, buffer + offset);
offset += sizeof(float); offset += sizeof(float);
result = getParam(arcseckeys::RATING_WEIGHT_MEAN_SUM, param);
if (result != RETURN_OK) {
return result;
}
addfloat(param, buffer + offset);
offset += sizeof(float);
result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param); result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param);
if (result != RETURN_OK) { if (result != RETURN_OK) {
return result; return result;
@ -632,3 +638,280 @@ ReturnValue_t Algo::createCommand(uint8_t* buffer) {
adduint8(param, buffer + offset); adduint8(param, buffer + offset);
return RETURN_OK; return RETURN_OK;
} }
LogLevel::LogLevel() : ArcsecJsonParamBase(arcseckeys::LOGLEVEL) {}
size_t LogLevel::getSize() { return COMMAND_SIZE; }
ReturnValue_t LogLevel::createCommand(uint8_t* buffer) {
ReturnValue_t result = RETURN_OK;
uint8_t offset = 0;
std::string param;
addSetParamHeader(buffer, StarTracker::ID::LOG_LEVEL);
offset = 2;
result = getParam(arcseckeys::LOGLEVEL1, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL2, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL3, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL4, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL5, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL6, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL7, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL8, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL9, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL10, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL11, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL12, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL13, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL14, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL15, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LOGLEVEL16, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
return RETURN_OK;
}
Subscription::Subscription() : ArcsecJsonParamBase(arcseckeys::SUBSCRIPTION) {}
size_t Subscription::getSize() { return COMMAND_SIZE; }
ReturnValue_t Subscription::createCommand(uint8_t* buffer) {
ReturnValue_t result = RETURN_OK;
uint8_t offset = 0;
std::string param;
addSetParamHeader(buffer, StarTracker::ID::SUBSCRIPTION);
offset = 2;
result = getParam(arcseckeys::TELEMETRY_1, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_2, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_3, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_4, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_5, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_6, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_7, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_8, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_9, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_10, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_11, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_12, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_13, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_14, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_15, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::TELEMETRY_16, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
return RETURN_OK;
}
LogSubscription::LogSubscription() : ArcsecJsonParamBase(arcseckeys::LOG_SUBSCRIPTION) {}
size_t LogSubscription::getSize() { return COMMAND_SIZE; }
ReturnValue_t LogSubscription::createCommand(uint8_t* buffer) {
ReturnValue_t result = RETURN_OK;
uint8_t offset = 0;
std::string param;
addSetParamHeader(buffer, StarTracker::ID::LOG_SUBSCRIPTION);
offset = 2;
result = getParam(arcseckeys::LEVEL1, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::MODULE1, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::LEVEL2, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
offset += sizeof(uint8_t);
result = getParam(arcseckeys::MODULE2, param);
if (result != RETURN_OK) {
return result;
}
adduint8(param, buffer + offset);
return RETURN_OK;
}
DebugCamera::DebugCamera() : ArcsecJsonParamBase(arcseckeys::DEBUG_CAMERA) {}
size_t DebugCamera::getSize() { return COMMAND_SIZE; }
ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) {
ReturnValue_t result = RETURN_OK;
uint8_t offset = 0;
std::string param;
addSetParamHeader(buffer, StarTracker::ID::DEBUG_CAMERA);
offset = 2;
result = getParam(arcseckeys::TIMING, param);
if (result != RETURN_OK) {
return result;
}
adduint32(param, buffer + offset);
offset += sizeof(uint32_t);
result = getParam(arcseckeys::TEST, param);
if (result != RETURN_OK) {
return result;
}
adduint32(param, buffer + offset);
return RETURN_OK;
}

64
linux/devices/startracker/StarTrackerJsonCommands.h
View File

@ -173,4 +173,68 @@ class Algo : public ArcsecJsonParamBase {
ReturnValue_t createCommand(uint8_t* buffer) override; ReturnValue_t createCommand(uint8_t* buffer) override;
}; };
/**
* @brief Generates command to configure the log level parameters.
*
*/
class LogLevel : public ArcsecJsonParamBase {
public:
LogLevel();
size_t getSize();
private:
static const size_t COMMAND_SIZE = 18;
ReturnValue_t createCommand(uint8_t* buffer) override;
};
/**
* @brief Generates command to set subscription parameters.
*
*/
class Subscription : public ArcsecJsonParamBase {
public:
Subscription();
size_t getSize();
private:
static const size_t COMMAND_SIZE = 18;
ReturnValue_t createCommand(uint8_t* buffer) override;
};
/**
* @brief Generates command to set log subscription parameters.
*
*/
class LogSubscription : public ArcsecJsonParamBase {
public:
LogSubscription();
size_t getSize();
private:
static const size_t COMMAND_SIZE = 6;
ReturnValue_t createCommand(uint8_t* buffer) override;
};
/**
* @brief Generates command to set debug camera parameters
*
*/
class DebugCamera : public ArcsecJsonParamBase {
public:
DebugCamera();
size_t getSize();
private:
static const size_t COMMAND_SIZE = 10;
ReturnValue_t createCommand(uint8_t* buffer) override;
};
#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_ */ #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_ */

4
linux/fsfwconfig/OBSWConfig.h.in
View File

@ -61,7 +61,7 @@ debugging. */
#endif #endif
#if defined EGSE #ifdef EGSE
#define OBSW_ADD_STAR_TRACKER 1 #define OBSW_ADD_STAR_TRACKER 1
#endif #endif
@ -108,7 +108,7 @@ debugging. */
#define OBSW_DEBUG_PLOC_SUPERVISOR 0 #define OBSW_DEBUG_PLOC_SUPERVISOR 0
#define OBSW_DEBUG_PDEC_HANDLER 0 #define OBSW_DEBUG_PDEC_HANDLER 0
#if defined EGSE #ifdef EGSE
#define OBSW_DEBUG_STARTRACKER 1 #define OBSW_DEBUG_STARTRACKER 1
#else #else
#define OBSW_DEBUG_STARTRACKER 0 #define OBSW_DEBUG_STARTRACKER 0

2
thirdparty/arcsec_star_tracker vendored

@ -1 +1 @@
Subproject commit aa1ebfc154558dad746a175d2efee52470fddefe Subproject commit 7cb426a6a1f1b25ac02d7bfd0792c412451c70af

2
tmtc

@ -1 +1 @@
Subproject commit 199ffe1a321c09ba9726c87413045f8b32f40e90 Subproject commit 5d8b9aac1fea707015bd991b865da7f3405859e8