star tracker commands, tracking, mounting, camera, blob
This commit is contained in:
Jakob Meier
@ -1,540 +0,0 @@
|
||||
#ifndef MISSION_STARTRACKER_DEFINITIONS_H_
|
||||
#define MISSION_STARTRACKER_DEFINITIONS_H_
|
||||
|
||||
#include <fsfw/datapoollocal/StaticLocalDataSet.h>
|
||||
#include <fsfw/datapoollocal/LocalPoolVariable.h>
|
||||
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
|
||||
#include "objects/systemObjectList.h"
|
||||
#include <fsfw/datapool/PoolReadGuard.h>
|
||||
|
||||
namespace StarTracker {
|
||||
|
||||
/** 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,
|
||||
|
||||
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,
|
||||
TRUST_WORTHY,
|
||||
STABLE_COUNT,
|
||||
SOLUTION_STRATEGY
|
||||
};
|
||||
|
||||
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 REBOOT = 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 SUBSCRIBE_TO_TM = 18;
|
||||
static const DeviceCommandId_t REQ_SOLUTION = 24;
|
||||
static const DeviceCommandId_t REQ_TEMPERATURE = 25;
|
||||
static const DeviceCommandId_t LIMITS = 40;
|
||||
static const DeviceCommandId_t MONTING = 41;
|
||||
static const DeviceCommandId_t CAMERA = 42;
|
||||
static const DeviceCommandId_t BLOB = 43;
|
||||
static const DeviceCommandId_t CENTROIDING = 44;
|
||||
static const DeviceCommandId_t LISA = 45;
|
||||
static const DeviceCommandId_t MACTHING = 46;
|
||||
static const DeviceCommandId_t TRACKING = 47;
|
||||
static const DeviceCommandId_t VALIDATION = 48;
|
||||
static const DeviceCommandId_t ALGO = 49;
|
||||
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;
|
||||
|
||||
/** Max size of unencoded frame */
|
||||
static const size_t MAX_FRAME_SIZE = 1200;
|
||||
|
||||
static const uint8_t TEMPERATURE_SET_ENTRIES = 4;
|
||||
static const uint8_t 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 = 23;
|
||||
|
||||
// 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 CAMERA = 9;
|
||||
static const uint8_t BLOB = 10;
|
||||
static const uint8_t CENTROIDING = 11;
|
||||
static const uint8_t LISA = 12;
|
||||
static const uint8_t MATCHING = 13;
|
||||
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 SUBSCRIBE = 18;
|
||||
static const uint8_t SOLUTION = 24;
|
||||
static const uint8_t TEMPERATURE = 25;
|
||||
static const uint8_t TIME = 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @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 interanl 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);
|
||||
|
||||
void printSet() {
|
||||
sif::info << "TemperatureSet::printSet: Ticks: "
|
||||
<< this->ticks << std::endl;
|
||||
sif::info << "TemperatureSet::printSet: Time: "
|
||||
<< this->time << " us" << std::endl;
|
||||
sif::info << "TemperatureSet::printSet: MCU Temperature: "
|
||||
<< this->mcuTemperature << " °C" << std::endl;
|
||||
sif::info << "TemperatureSet::printSet: CMOS Temperature: "
|
||||
<< this->cmosTemperature << " °C" << 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)) {
|
||||
}
|
||||
|
||||
// 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_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: "
|
||||
<< 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> time = 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);
|
||||
// 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->time << 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;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */
|
||||
@ -1,343 +0,0 @@
|
||||
#ifndef BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_
|
||||
#define BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <filesystem>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "fsfw/serviceinterface/ServiceInterface.h"
|
||||
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
|
||||
#include "bsp_q7s/devices/devicedefinitions/StarTrackerDefinitions.h"
|
||||
|
||||
#include "thirdparty/arcsec_star_tracker/common/generated/tmtcstructs.h"
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
/**
|
||||
* @brief This file defines a few helper classes to generate commands by means of the arcsec
|
||||
* json files.
|
||||
* @author J. Meier
|
||||
*/
|
||||
|
||||
namespace arcseckeys {
|
||||
static const char PROPERTIES[] = "properties";
|
||||
static const char NAME[] = "name";
|
||||
static const char VALUE[] = "value";
|
||||
|
||||
static const char LIMITS[] = "limits";
|
||||
static const char ACTION[] = "action";
|
||||
static const char FPGA18CURRENT[] = "FPGA18Current";
|
||||
static const char FPGA25CURRENT[] = "FPGA25Current";
|
||||
static const char FPGA10CURRENT[] = "FPGA10Current";
|
||||
static const char MCUCURRENT[] = "MCUCurrent";
|
||||
static const char CMOS21CURRENT[] = "CMOS21Current";
|
||||
static const char CMOSPIXCURRENT[] = "CMOSPixCurrent";
|
||||
static const char CMOS33CURRENT[] = "CMOS33Current";
|
||||
static const char CMOSVRESCURRENT[] = "CMOSVResCurrent";
|
||||
static const char CMOS_TEMPERATURE[] = "CMOSTemperature";
|
||||
static const char MCU_TEMPERATURE[] = "MCUTemperature";
|
||||
|
||||
static const char TRACKING[] = "tracking";
|
||||
static const char THIN_LIMIT[] = "thinLimit";
|
||||
static const char OUTLIER_THRESHOLD[] = "outlierThreshold";
|
||||
static const char OUTLIER_THRESHOLD_QUEST[] = "outlierThresholdQUEST";
|
||||
static const char TRACKER_CHOICE[] = "trackerChoice";
|
||||
}
|
||||
|
||||
class ArcsecJsonBase : public HasReturnvaluesIF {
|
||||
public:
|
||||
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::ARCSEC_JSON_BASE;
|
||||
//! [EXPORT] : [COMMENT] Specified json file does not exist
|
||||
static const ReturnValue_t JSON_FILE_NOT_EXISTS = MAKE_RETURN_CODE(1);
|
||||
//! [EXPORT] : [COMMENT] Requested set does not exist in json file
|
||||
static const ReturnValue_t SET_NOT_EXISTS = MAKE_RETURN_CODE(2);
|
||||
//! [EXPORT] : [COMMENT] Requested parameter does not exist in json file
|
||||
static const ReturnValue_t PARAM_NOT_EXISTS = MAKE_RETURN_CODE(3);
|
||||
|
||||
/**
|
||||
* @brief Constructor
|
||||
*
|
||||
* @param fullname Name with absolute path of json file containing the parameters to set.
|
||||
*/
|
||||
ArcsecJsonBase() {}
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
* @brief Initializes the properties json object and the set json object
|
||||
*
|
||||
* @param fullname Name including absolute path to json file
|
||||
* @param setName The name of the set to work on
|
||||
*
|
||||
* @param return JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise
|
||||
* RETURN_OK
|
||||
*/
|
||||
ReturnValue_t init(const std::string filename,std::string setName) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
if(not std::filesystem::exists(filename)) {
|
||||
sif::warning << "ArcsecJsonBase::init: JSON file " << filename << " does not exist"
|
||||
<< std::endl;
|
||||
return JSON_FILE_NOT_EXISTS;
|
||||
}
|
||||
createJsonObject(filename);
|
||||
result = initSet(setName);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reads the value of a parameter from a json set
|
||||
*
|
||||
* @param name The name of the parameter
|
||||
* @param value The string representation of the read value
|
||||
*
|
||||
* @return RETURN_OK if successful, otherwise PARAM_NOT_EXISTS
|
||||
*/
|
||||
ReturnValue_t getParam(const std::string name, std::string& value) {
|
||||
for (json::iterator it = set.begin(); it != set.end(); ++it) {
|
||||
if ((*it)[arcseckeys::NAME] == name) {
|
||||
value = (*it)[arcseckeys::VALUE];
|
||||
return RETURN_OK;
|
||||
}
|
||||
}
|
||||
return PARAM_NOT_EXISTS;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function adds a float represented as string to a buffer
|
||||
*
|
||||
* @param value The float in string representation to add
|
||||
* @param buffer Pointer to the buffer the float will be written to
|
||||
*/
|
||||
void addfloat(const std::string value, uint8_t* buffer) {
|
||||
float param = std::stof(value);
|
||||
std::memcpy(buffer, ¶m, sizeof(param));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function adds a uint8_t represented as string to a buffer
|
||||
*
|
||||
* @param value The uint8_t in string representation to add
|
||||
* @param buffer Pointer to the buffer the uint8_t will be written to
|
||||
*/
|
||||
void adduint8(const std::string value, uint8_t* buffer) {
|
||||
uint8_t param = std::stoi(value);
|
||||
std::memcpy(buffer, ¶m, sizeof(param));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function adds a uint32_t represented as string to a buffer
|
||||
*
|
||||
* @param value The uint32_t in string representation to add
|
||||
* @param buffer Pointer to the buffer the uint32_t will be written to
|
||||
*/
|
||||
void adduint32(const std::string value, uint8_t* buffer) {
|
||||
uint32_t param = std::stoi(value);
|
||||
std::memcpy(buffer, ¶m, sizeof(param));
|
||||
}
|
||||
|
||||
void addSetParamHeader(uint8_t* buffer, uint8_t setId) {
|
||||
*buffer = static_cast<uint8_t>(TMTC_SETPARAMREQ);
|
||||
*(buffer + 1) = setId;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void createJsonObject(const std::string fullname) {
|
||||
json j;
|
||||
std::ifstream file(fullname);
|
||||
file >> j;
|
||||
file.close();
|
||||
properties = j[arcseckeys::PROPERTIES];
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Extracts the json set object form the json file
|
||||
*
|
||||
* @param setName The name of the set to create the json object from
|
||||
*/
|
||||
ReturnValue_t initSet(std::string setName) {
|
||||
for (json::iterator it = properties.begin(); it != properties.end(); ++it) {
|
||||
if ((*it)["name"] == setName) {
|
||||
set = (*it)["fields"];
|
||||
return RETURN_OK;
|
||||
}
|
||||
}
|
||||
return SET_NOT_EXISTS;
|
||||
}
|
||||
|
||||
json properties;
|
||||
json set;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Generates command to set the limit parameters
|
||||
*
|
||||
*/
|
||||
class Limits : public ArcsecJsonBase {
|
||||
public:
|
||||
|
||||
static const size_t COMMAND_SIZE = 43;
|
||||
|
||||
Limits() {}
|
||||
|
||||
/**
|
||||
* @brief Fills a buffer with the tracking parameters
|
||||
*
|
||||
* @param fullname The name including the absolute path of the json file containing the
|
||||
* limits parameters to set.
|
||||
* @param buffer Pointer to the buffer the command will be written to
|
||||
*/
|
||||
ReturnValue_t create(std::string fullname, uint8_t* buffer) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
result = init(fullname, arcseckeys::LIMITS);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = createCommand(buffer);
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
ReturnValue_t createCommand(uint8_t* buffer) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
uint8_t offset = 0;
|
||||
std::string param;
|
||||
addSetParamHeader(buffer, StarTracker::ID::LIMITS);
|
||||
offset = 2;
|
||||
result = getParam(arcseckeys::ACTION, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
adduint8(param, buffer + offset);
|
||||
offset += sizeof(uint8_t);
|
||||
result = getParam(arcseckeys::FPGA18CURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::FPGA25CURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::FPGA10CURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::MCUCURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::CMOS21CURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::CMOSPIXCURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::CMOS33CURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::CMOSVRESCURRENT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::CMOS_TEMPERATURE, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::MCU_TEMPERATURE, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
return RETURN_OK;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Generates the command to configure the tracking algorithm.
|
||||
*
|
||||
*/
|
||||
class Tracking : public ArcsecJsonBase {
|
||||
public:
|
||||
|
||||
static const size_t COMMAND_SIZE = 15;
|
||||
|
||||
Tracking() {}
|
||||
/**
|
||||
* @brief Fills a buffer with the tracking parameters
|
||||
*
|
||||
* @param fullname The name including the absolute path of the json file containing the
|
||||
* tracking parameters to set.
|
||||
* @param buffer Pointer to the buffer the command will be written to
|
||||
*/
|
||||
ReturnValue_t create(std::string fullname, uint8_t* buffer) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
result = init(fullname, arcseckeys::TRACKING);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = createCommand(buffer);
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
ReturnValue_t createCommand(uint8_t* buffer) {
|
||||
ReturnValue_t result = RETURN_OK;
|
||||
uint8_t offset = 0;
|
||||
std::string param;
|
||||
addSetParamHeader(buffer, StarTracker::ID::TRACKING);
|
||||
offset = 2;
|
||||
result = getParam(arcseckeys::THIN_LIMIT, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::OUTLIER_THRESHOLD, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::OUTLIER_THRESHOLD_QUEST, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
addfloat(param, buffer + offset);
|
||||
offset += sizeof(float);
|
||||
result = getParam(arcseckeys::TRACKER_CHOICE, param);
|
||||
if (result != RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
adduint8(param, buffer + offset);
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_ */
|
||||
Reference in New Issue
Block a user