Merge remote-tracking branch 'origin/develop' into mueller/pus-15-tm-storage
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good
All checks were successful
EIVE/eive-obsw/pipeline/pr-develop This commit looks good
This commit is contained in:
@ -5,6 +5,7 @@
|
||||
#include <fsfw/globalfunctions/math/VectorOperations.h>
|
||||
#include <fsfw/parameters/ParameterHelper.h>
|
||||
#include <fsfw/parameters/ReceivesParameterMessagesIF.h>
|
||||
#include <mission/devices/devicedefinitions/imtqHelpers.h>
|
||||
#include <mission/devices/devicedefinitions/rwHelpers.h>
|
||||
|
||||
#include "acs/ActuatorCmd.h"
|
||||
@ -19,7 +20,6 @@
|
||||
#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
|
||||
#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
|
||||
#include "mission/devices/devicedefinitions/SusDefinitions.h"
|
||||
#include "mission/devices/devicedefinitions/imtqHandlerDefinitions.h"
|
||||
#include "mission/trace.h"
|
||||
|
||||
class AcsController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
|
||||
@ -84,7 +84,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
|
||||
ACS::SensorValues sensorValues;
|
||||
|
||||
/* ACS Actuation Datasets */
|
||||
IMTQ::DipoleActuationSet dipoleSet = IMTQ::DipoleActuationSet(objects::IMTQ_HANDLER);
|
||||
imtq::DipoleActuationSet dipoleSet = imtq::DipoleActuationSet(objects::IMTQ_HANDLER);
|
||||
rws::RwSpeedActuationSet rw1SpeedSet = rws::RwSpeedActuationSet(objects::RW1);
|
||||
rws::RwSpeedActuationSet rw2SpeedSet = rws::RwSpeedActuationSet(objects::RW2);
|
||||
rws::RwSpeedActuationSet rw3SpeedSet = rws::RwSpeedActuationSet(objects::RW3);
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
#include <mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h>
|
||||
#include <mission/devices/devicedefinitions/GyroL3GD20Definitions.h>
|
||||
#include <mission/devices/devicedefinitions/SyrlinksDefinitions.h>
|
||||
#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>
|
||||
#include <mission/devices/devicedefinitions/imtqHelpers.h>
|
||||
#include <mission/devices/devicedefinitions/payloadPcduDefinitions.h>
|
||||
#include <mission/devices/devicedefinitions/rwHelpers.h>
|
||||
#include <objects/systemObjectList.h>
|
||||
@ -785,7 +785,7 @@ void ThermalController::copyDevices() {
|
||||
}
|
||||
|
||||
{
|
||||
lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, IMTQ::MCU_TEMPERATURE);
|
||||
lp_var_t<int16_t> tempMgt = lp_var_t<int16_t>(objects::IMTQ_HANDLER, imtq::MCU_TEMPERATURE);
|
||||
PoolReadGuard pg(&tempMgt, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
|
||||
if (pg.getReadResult() != returnvalue::OK) {
|
||||
sif::warning << "ThermalController: Failed to read MGT temperature" << std::endl;
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#ifndef SENSORVALUES_H_
|
||||
#define SENSORVALUES_H_
|
||||
|
||||
#include <mission/devices/devicedefinitions/imtqHelpers.h>
|
||||
#include <mission/devices/devicedefinitions/rwHelpers.h>
|
||||
|
||||
#include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
|
||||
@ -10,7 +11,6 @@
|
||||
#include "mission/devices/devicedefinitions/GPSDefinitions.h"
|
||||
#include "mission/devices/devicedefinitions/GyroADIS1650XDefinitions.h"
|
||||
#include "mission/devices/devicedefinitions/SusDefinitions.h"
|
||||
#include "mission/devices/devicedefinitions/imtqHandlerDefinitions.h"
|
||||
|
||||
namespace ACS {
|
||||
|
||||
@ -35,7 +35,8 @@ class SensorValues {
|
||||
MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER);
|
||||
RM3100::Rm3100PrimaryDataset mgm3Rm3100Set =
|
||||
RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER);
|
||||
IMTQ::RawMtmMeasurementSet imtqMgmSet = IMTQ::RawMtmMeasurementSet(objects::IMTQ_HANDLER);
|
||||
imtq::RawMtmMeasurementNoTorque imtqMgmSet =
|
||||
imtq::RawMtmMeasurementNoTorque(objects::IMTQ_HANDLER);
|
||||
|
||||
std::array<SUS::SusDataset, 12> susSets{
|
||||
SUS::SusDataset(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -2,7 +2,7 @@
|
||||
#define MISSION_DEVICES_IMTQHANDLER_H_
|
||||
|
||||
#include <fsfw/devicehandlers/DeviceHandlerBase.h>
|
||||
#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>
|
||||
#include <mission/devices/devicedefinitions/imtqHelpers.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "events/subsystemIdRanges.h"
|
||||
@ -23,7 +23,6 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
|
||||
void setPollingMode(NormalPollingMode pollMode);
|
||||
|
||||
void doSendRead() override;
|
||||
/**
|
||||
* @brief Sets mode to MODE_NORMAL. Can be used for debugging.
|
||||
*/
|
||||
@ -32,6 +31,7 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
void setDebugMode(bool enable);
|
||||
|
||||
protected:
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
void doStartUp() override;
|
||||
void doShutDown() override;
|
||||
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
|
||||
@ -42,7 +42,6 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
|
||||
size_t* foundLen) override;
|
||||
ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
|
||||
void setNormalDatapoolEntriesInvalid() override;
|
||||
virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
|
||||
uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
@ -50,19 +49,6 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) override;
|
||||
|
||||
private:
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::IMTQ_HANDLER;
|
||||
|
||||
static const ReturnValue_t INVALID_COMMAND_CODE = MAKE_RETURN_CODE(0xA0);
|
||||
static const ReturnValue_t PARAMETER_MISSING = MAKE_RETURN_CODE(0xA1);
|
||||
static const ReturnValue_t PARAMETER_INVALID = MAKE_RETURN_CODE(0xA2);
|
||||
static const ReturnValue_t CC_UNAVAILABLE = MAKE_RETURN_CODE(0xA3);
|
||||
static const ReturnValue_t INTERNAL_PROCESSING_ERROR = MAKE_RETURN_CODE(0xA4);
|
||||
static const ReturnValue_t REJECTED_WITHOUT_REASON = MAKE_RETURN_CODE(0xA5);
|
||||
static const ReturnValue_t CMD_ERR_UNKNOWN = MAKE_RETURN_CODE(0xA6);
|
||||
//! [EXPORT] : [COMMENT] The status reply to a self test command was received but no self test
|
||||
//! command has been sent. This should normally never happen.
|
||||
static const ReturnValue_t UNEXPECTED_SELF_TEST_REPLY = MAKE_RETURN_CODE(0xA7);
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::IMTQ_HANDLER;
|
||||
|
||||
//! [EXPORT] : [COMMENT] Get self test result returns I2C failure
|
||||
@ -97,49 +83,43 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
//! link between IMTQ and OBC.
|
||||
static const Event INVALID_ERROR_BYTE = MAKE_EVENT(8, severity::LOW);
|
||||
|
||||
IMTQ::EngHkDataset engHkDataset;
|
||||
IMTQ::CalibratedMtmMeasurementSet calMtmMeasurementSet;
|
||||
IMTQ::RawMtmMeasurementSet rawMtmMeasurementSet;
|
||||
IMTQ::DipoleActuationSet dipoleSet;
|
||||
IMTQ::PosXSelfTestSet posXselfTestDataset;
|
||||
IMTQ::NegXSelfTestSet negXselfTestDataset;
|
||||
IMTQ::PosYSelfTestSet posYselfTestDataset;
|
||||
IMTQ::NegYSelfTestSet negYselfTestDataset;
|
||||
IMTQ::PosZSelfTestSet posZselfTestDataset;
|
||||
IMTQ::NegZSelfTestSet negZselfTestDataset;
|
||||
imtq::StatusDataset statusSet;
|
||||
imtq::DipoleActuationSet dipoleSet;
|
||||
imtq::RawMtmMeasurementNoTorque rawMtmNoTorque;
|
||||
imtq::HkDatasetNoTorque hkDatasetNoTorque;
|
||||
|
||||
imtq::RawMtmMeasurementWithTorque rawMtmWithTorque;
|
||||
imtq::HkDatasetWithTorque hkDatasetWithTorque;
|
||||
|
||||
imtq::CalibratedMtmMeasurementSet calMtmMeasurementSet;
|
||||
imtq::PosXSelfTestSet posXselfTestDataset;
|
||||
imtq::NegXSelfTestSet negXselfTestDataset;
|
||||
imtq::PosYSelfTestSet posYselfTestDataset;
|
||||
imtq::NegYSelfTestSet negYselfTestDataset;
|
||||
imtq::PosZSelfTestSet posZselfTestDataset;
|
||||
imtq::NegZSelfTestSet negZselfTestDataset;
|
||||
|
||||
NormalPollingMode pollingMode = NormalPollingMode::UNCALIBRATED;
|
||||
|
||||
PoolEntry<uint8_t> statusMode = PoolEntry<uint8_t>({0});
|
||||
PoolEntry<uint8_t> statusError = PoolEntry<uint8_t>({0});
|
||||
PoolEntry<uint8_t> statusConfig = PoolEntry<uint8_t>({0});
|
||||
PoolEntry<uint32_t> statusUptime = PoolEntry<uint32_t>({0});
|
||||
|
||||
PoolEntry<int32_t> mgmCalEntry = PoolEntry<int32_t>(3);
|
||||
PoolEntry<int16_t> dipoleXEntry = PoolEntry<int16_t>(0, false);
|
||||
PoolEntry<int16_t> dipoleYEntry = PoolEntry<int16_t>(0, false);
|
||||
PoolEntry<int16_t> dipoleZEntry = PoolEntry<int16_t>(0, false);
|
||||
PoolEntry<uint16_t> torqueDurationEntry = PoolEntry<uint16_t>(0, false);
|
||||
// Hardcoded to default integration time of 10 ms.
|
||||
// SHOULDDO: Support for other integration times
|
||||
Countdown integrationTimeCd = Countdown(10);
|
||||
|
||||
power::Switch_t switcher = power::NO_SWITCH;
|
||||
|
||||
uint8_t commandBuffer[IMTQ::MAX_COMMAND_SIZE];
|
||||
uint8_t commandBuffer[imtq::MAX_COMMAND_SIZE];
|
||||
bool goToNormalMode = false;
|
||||
bool debugMode = false;
|
||||
bool specialRequestActive = false;
|
||||
bool firstReplyCycle = true;
|
||||
|
||||
enum class CommunicationStep {
|
||||
GET_ENG_HK_DATA,
|
||||
START_MTM_MEASUREMENT,
|
||||
GET_CAL_MTM_MEASUREMENT,
|
||||
GET_RAW_MTM_MEASUREMENT,
|
||||
DIPOLE_ACTUATION
|
||||
};
|
||||
|
||||
CommunicationStep communicationStep = CommunicationStep::GET_ENG_HK_DATA;
|
||||
|
||||
enum class StartupStep { NONE, COMMAND_SELF_TEST, GET_SELF_TEST_RESULT };
|
||||
|
||||
StartupStep startupStep = StartupStep::COMMAND_SELF_TEST;
|
||||
|
||||
bool selfTestPerformed = false;
|
||||
imtq::RequestType requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
|
||||
|
||||
/**
|
||||
* @brief In case of a status reply to a single axis self test command, this function
|
||||
@ -155,7 +135,7 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
*
|
||||
* @return The return code derived from the received status byte.
|
||||
*/
|
||||
ReturnValue_t parseStatusByte(const uint8_t* packet);
|
||||
ReturnValue_t parseStatusByte(imtq::CC::CC command, const uint8_t* packet);
|
||||
|
||||
/**
|
||||
* @brief This function fills the engineering housekeeping dataset with the received data.
|
||||
@ -163,23 +143,9 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
* @param packet Pointer to the received data.
|
||||
*
|
||||
*/
|
||||
void fillEngHkDataset(const uint8_t* packet);
|
||||
void fillEngHkDataset(imtq::HkDataset& hkDataset, const uint8_t* packet);
|
||||
|
||||
/**
|
||||
* @brief This function sends a command reply to the requesting queue.
|
||||
*
|
||||
* @param data Pointer to the data to send.
|
||||
* @param dataSize Size of the data to send.
|
||||
* @param relplyId Reply id which will be inserted at the beginning of the action message.
|
||||
*/
|
||||
void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
|
||||
|
||||
/**
|
||||
* @brief This function handles the reply containing the commanded dipole.
|
||||
*
|
||||
* @param packet Pointer to the reply data.
|
||||
*/
|
||||
void handleGetCommandedDipoleReply(const uint8_t* packet);
|
||||
void fillSystemStateIntoDataset(const uint8_t* packet);
|
||||
|
||||
/**
|
||||
* @brief This function parses the reply containing the calibrated MTM measurement and writes
|
||||
@ -212,7 +178,7 @@ class ImtqHandler : public DeviceHandlerBase {
|
||||
void handlePositiveZSelfTestReply(const uint8_t* packet);
|
||||
void handleNegativeZSelfTestReply(const uint8_t* packet);
|
||||
|
||||
ReturnValue_t buildDipoleActuationCommand();
|
||||
// ReturnValue_t buildDipoleActuationCommand();
|
||||
/**
|
||||
* @brief This function checks the error byte of a self test measurement.
|
||||
*
|
||||
|
||||
@ -1 +1,2 @@
|
||||
target_sources(${LIB_EIVE_MISSION} PRIVATE ScexDefinitions.cpp rwHelpers.cpp)
|
||||
target_sources(${LIB_EIVE_MISSION} PRIVATE ScexDefinitions.cpp rwHelpers.cpp
|
||||
imtqHelpers.cpp)
|
||||
|
||||
49
mission/devices/devicedefinitions/imtqHelpers.cpp
Normal file
49
mission/devices/devicedefinitions/imtqHelpers.cpp
Normal file
@ -0,0 +1,49 @@
|
||||
#include "imtqHelpers.h"
|
||||
|
||||
size_t imtq::getReplySize(CC::CC cc, size_t* optSecondSize) {
|
||||
switch (cc) {
|
||||
// Software reset is a bit special and can also cause a I2C NAK because
|
||||
// the device might be reset at that moment. Otherwise, 2 bytes should be returned
|
||||
case (CC::CC::SOFTWARE_RESET): {
|
||||
if (optSecondSize != nullptr) {
|
||||
*optSecondSize = 0;
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
case (CC::CC::START_ACTUATION_DIPOLE):
|
||||
case (CC::CC::SELF_TEST_CMD):
|
||||
case (CC::CC::START_MTM_MEASUREMENT): {
|
||||
return 2;
|
||||
}
|
||||
case (CC::CC::GET_SYSTEM_STATE): {
|
||||
return 9;
|
||||
}
|
||||
case (CC::CC::GET_RAW_MTM_MEASUREMENT):
|
||||
case (CC::CC::GET_CAL_MTM_MEASUREMENT): {
|
||||
return 15;
|
||||
}
|
||||
case (CC::CC::GET_COIL_CURRENT):
|
||||
case (CC::CC::GET_COMMANDED_DIPOLE):
|
||||
case (CC::CC::GET_COIL_TEMPERATURES): {
|
||||
return 8;
|
||||
}
|
||||
case (CC::CC::GET_SELF_TEST_RESULT): {
|
||||
// Can also be 360 for the all axes self-test!
|
||||
if (optSecondSize != nullptr) {
|
||||
*optSecondSize = 360;
|
||||
}
|
||||
return 120;
|
||||
}
|
||||
case (CC::CC::GET_RAW_HK_DATA):
|
||||
case (CC::CC::GET_ENG_HK_DATA): {
|
||||
return 24;
|
||||
}
|
||||
case (CC::CC::GET_PARAM): {
|
||||
return imtq::replySize::MAX_SET_GET_PARAM_LEN;
|
||||
}
|
||||
default: {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -1,23 +1,60 @@
|
||||
#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_IMTQDEFINITIONS_H_
|
||||
#define MISSION_DEVICES_DEVICEDEFINITIONS_IMTQDEFINITIONS_H_
|
||||
|
||||
#include <eive/resultClassIds.h>
|
||||
#include <fsfw/datapool/PoolReadGuard.h>
|
||||
#include <fsfw/datapoollocal/StaticLocalDataSet.h>
|
||||
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
|
||||
|
||||
class ImtqHandler;
|
||||
|
||||
namespace IMTQ {
|
||||
namespace imtq {
|
||||
|
||||
static const DeviceCommandId_t NONE = 0x0;
|
||||
static const DeviceCommandId_t GET_ENG_HK_DATA = 0x1;
|
||||
enum ComStep : uint8_t {
|
||||
DHB_OP = 0,
|
||||
START_MEASURE_SEND = 1,
|
||||
START_MEASURE_GET = 2,
|
||||
READ_MEASURE_SEND = 3,
|
||||
READ_MEASURE_GET = 4,
|
||||
START_ACTUATE_SEND = 5,
|
||||
START_ACTUATE_GET = 6,
|
||||
READ_ACTUATE_SEND = 7,
|
||||
READ_ACTUATE_GET = 8,
|
||||
};
|
||||
|
||||
enum class RequestType : uint8_t { MEASURE_NO_ACTUATION, ACTUATE };
|
||||
|
||||
enum class SpecialRequest : uint8_t {
|
||||
NONE = 0,
|
||||
DO_SELF_TEST_POS_X = 1,
|
||||
DO_SELF_TEST_NEG_X = 2,
|
||||
DO_SELF_TEST_POS_Y = 3,
|
||||
DO_SELF_TEST_NEG_Y = 4,
|
||||
DO_SELF_TEST_POS_Z = 5,
|
||||
DO_SELF_TEST_NEG_Z = 6,
|
||||
GET_SELF_TEST_RESULT = 7
|
||||
};
|
||||
|
||||
static const uint8_t INTERFACE_ID = CLASS_ID::IMTQ_HANDLER;
|
||||
|
||||
static constexpr ReturnValue_t INVALID_COMMAND_CODE = MAKE_RETURN_CODE(0);
|
||||
static constexpr ReturnValue_t MGM_MEASUREMENT_LOW_LEVEL_ERROR = MAKE_RETURN_CODE(1);
|
||||
static constexpr ReturnValue_t ACTUATE_CMD_LOW_LEVEL_ERROR = MAKE_RETURN_CODE(2);
|
||||
static const ReturnValue_t PARAMETER_MISSING = MAKE_RETURN_CODE(3);
|
||||
static const ReturnValue_t PARAMETER_INVALID = MAKE_RETURN_CODE(4);
|
||||
static const ReturnValue_t CC_UNAVAILABLE = MAKE_RETURN_CODE(5);
|
||||
static const ReturnValue_t INTERNAL_PROCESSING_ERROR = MAKE_RETURN_CODE(6);
|
||||
static const ReturnValue_t REJECTED_WITHOUT_REASON = MAKE_RETURN_CODE(7);
|
||||
static const ReturnValue_t CMD_ERR_UNKNOWN = MAKE_RETURN_CODE(8);
|
||||
//! [EXPORT] : [COMMENT] The status reply to a self test command was received but no self test
|
||||
//! command has been sent. This should normally never happen.
|
||||
static const ReturnValue_t UNEXPECTED_SELF_TEST_REPLY = MAKE_RETURN_CODE(0xA7);
|
||||
|
||||
namespace cmdIds {
|
||||
|
||||
static constexpr DeviceCommandId_t REQUEST = 0x70;
|
||||
static constexpr DeviceCommandId_t REPLY = 0x71;
|
||||
static const DeviceCommandId_t START_ACTUATION_DIPOLE = 0x2;
|
||||
static const DeviceCommandId_t GET_COMMANDED_DIPOLE = 0x3;
|
||||
/** Generates new measurement of the magnetic field */
|
||||
static const DeviceCommandId_t START_MTM_MEASUREMENT = 0x4;
|
||||
/** Requests the calibrated magnetometer measurement */
|
||||
static const DeviceCommandId_t GET_CAL_MTM_MEASUREMENT = 0x5;
|
||||
/** Requests the raw values measured by the built-in MTM XEN1210 */
|
||||
static const DeviceCommandId_t GET_RAW_MTM_MEASUREMENT = 0x6;
|
||||
static const DeviceCommandId_t POS_X_SELF_TEST = 0x7;
|
||||
static const DeviceCommandId_t NEG_X_SELF_TEST = 0x8;
|
||||
static const DeviceCommandId_t POS_Y_SELF_TEST = 0x9;
|
||||
@ -26,36 +63,49 @@ static const DeviceCommandId_t POS_Z_SELF_TEST = 0xB;
|
||||
static const DeviceCommandId_t NEG_Z_SELF_TEST = 0xC;
|
||||
static const DeviceCommandId_t GET_SELF_TEST_RESULT = 0xD;
|
||||
|
||||
static const uint8_t GET_TEMP_REPLY_SIZE = 2;
|
||||
static const uint8_t CFGR_CMD_SIZE = 3;
|
||||
} // namespace cmdIds
|
||||
|
||||
static const uint8_t POINTER_REG_SIZE = 1;
|
||||
|
||||
enum SetIds : uint32_t {
|
||||
ENG_HK = 1,
|
||||
CAL_MGM = 2,
|
||||
RAW_MGM = 3,
|
||||
POS_X_TEST = 4,
|
||||
NEG_X_TEST = 5,
|
||||
POS_Y_TEST = 6,
|
||||
NEG_Y_TEST = 7,
|
||||
POS_Z_TEST = 8,
|
||||
NEG_Z_TEST = 9,
|
||||
DIPOLES = 10
|
||||
ENG_HK_NO_TORQUE = 1,
|
||||
RAW_MTM_NO_TORQUE = 2,
|
||||
ENG_HK_SET_WITH_TORQUE = 3,
|
||||
RAW_MTM_WITH_TORQUE = 4,
|
||||
STATUS_SET = 5,
|
||||
DIPOLES = 6,
|
||||
|
||||
CAL_MTM_SET = 9,
|
||||
POSITIVE_X_TEST = 10,
|
||||
NEGATIVE_X_TEST = 11,
|
||||
POSITIVE_Y_TEST = 12,
|
||||
NEGATIVE_Y_TEST = 13,
|
||||
POSITIVE_Z_TEST = 14,
|
||||
NEGATIVE_Z_TEST = 15,
|
||||
};
|
||||
|
||||
static const uint8_t SIZE_ENG_HK_COMMAND = 1;
|
||||
static const uint8_t SIZE_STATUS_REPLY = 2;
|
||||
static const uint8_t SIZE_ENG_HK_DATA_REPLY = 24;
|
||||
static const uint8_t SIZE_GET_COMMANDED_DIPOLE_REPLY = 8;
|
||||
static const uint8_t SIZE_GET_CAL_MTM_MEASUREMENT = 15;
|
||||
static const uint8_t SIZE_GET_RAW_MTM_MEASUREMENT = 15;
|
||||
static const uint16_t SIZE_SELF_TEST_RESULTS = 120;
|
||||
namespace replySize {
|
||||
|
||||
static const uint16_t MAX_REPLY_SIZE = SIZE_SELF_TEST_RESULTS;
|
||||
static const uint8_t MAX_COMMAND_SIZE = 9;
|
||||
static constexpr uint8_t GET_TEMP_REPLY_SIZE = 2;
|
||||
static constexpr uint8_t CFGR_CMD_SIZE = 3;
|
||||
static constexpr size_t DEFAULT_MIN_LEN = 2;
|
||||
static constexpr size_t STATUS_REPLY = DEFAULT_MIN_LEN;
|
||||
static constexpr size_t ENG_HK_DATA_REPLY = 24;
|
||||
static constexpr size_t GET_COMMANDED_DIPOLE_REPLY = 8;
|
||||
static constexpr size_t MAX_SET_GET_PARAM_LEN = 12;
|
||||
static constexpr size_t SYSTEM_STATE = 9;
|
||||
static constexpr size_t CAL_MTM_MEASUREMENT = 15;
|
||||
static constexpr size_t RAW_MTM_MEASUREMENT = 15;
|
||||
static constexpr size_t SELF_TEST_RESULTS = 120;
|
||||
static constexpr size_t SELF_TEST_RESULTS_ALL_AXES = 360;
|
||||
|
||||
} // namespace replySize
|
||||
|
||||
static const uint16_t MAX_REPLY_SIZE = replySize::SELF_TEST_RESULTS_ALL_AXES;
|
||||
static const uint8_t MAX_COMMAND_SIZE = 16;
|
||||
|
||||
/** Define entries in IMTQ specific dataset */
|
||||
static const uint8_t ENG_HK_SET_POOL_ENTRIES = 11;
|
||||
static const uint8_t HK_SET_POOL_ENTRIES = 20;
|
||||
static const uint8_t CAL_MTM_POOL_ENTRIES = 4;
|
||||
static const uint8_t SELF_TEST_DATASET_ENTRIES = 104;
|
||||
|
||||
@ -72,45 +122,75 @@ static const uint8_t INVALID_ERROR_BYTE =
|
||||
|
||||
static const uint8_t MAIN_STEP_OFFSET = 43;
|
||||
|
||||
// Command Code
|
||||
namespace CC {
|
||||
|
||||
/**
|
||||
* Command code definitions. Each command or reply of an IMTQ request will begin with one of
|
||||
* the following command codes.
|
||||
*/
|
||||
namespace CC {
|
||||
static const uint8_t START_MTM_MEASUREMENT = 0x4;
|
||||
static const uint8_t START_ACTUATION_DIPOLE = 0x6;
|
||||
static const uint8_t SELF_TEST_CMD = 0x8;
|
||||
static const uint8_t SOFTWARE_RESET = 0xAA;
|
||||
static const uint8_t GET_ENG_HK_DATA = 0x4A;
|
||||
static const uint8_t GET_COMMANDED_DIPOLE = 0x46;
|
||||
static const uint8_t GET_RAW_MTM_MEASUREMENT = 0x42;
|
||||
static const uint8_t GET_CAL_MTM_MEASUREMENT = 0x43;
|
||||
static const uint8_t GET_SELF_TEST_RESULT = 0x47;
|
||||
static const uint8_t PAST_AVAILABLE_RESPONSE_BYTES = 0xff;
|
||||
}; // namespace CC
|
||||
enum CC : uint8_t {
|
||||
START_MTM_MEASUREMENT = 0x4,
|
||||
START_ACTUATION_DIPOLE = 0x6,
|
||||
SELF_TEST_CMD = 0x8,
|
||||
GET_SYSTEM_STATE = 0x41,
|
||||
GET_RAW_MTM_MEASUREMENT = 0x42,
|
||||
GET_CAL_MTM_MEASUREMENT = 0x43,
|
||||
GET_COIL_CURRENT = 0x44,
|
||||
GET_COIL_TEMPERATURES = 0x45,
|
||||
GET_COMMANDED_DIPOLE = 0x46,
|
||||
GET_SELF_TEST_RESULT = 0x47,
|
||||
GET_RAW_HK_DATA = 0x49,
|
||||
GET_ENG_HK_DATA = 0x4A,
|
||||
GET_PARAM = 0x81,
|
||||
SET_PARAM = 0x82,
|
||||
SOFTWARE_RESET = 0xAA,
|
||||
PAST_AVAILABLE_RESPONSE_BYTES = 0xff
|
||||
};
|
||||
|
||||
namespace SELF_TEST_AXIS {
|
||||
static const uint8_t ALL = 0x0;
|
||||
static const uint8_t X_POSITIVE = 0x1;
|
||||
static const uint8_t X_NEGATIVE = 0x2;
|
||||
static const uint8_t Y_POSITIVE = 0x3;
|
||||
static const uint8_t Y_NEGATIVE = 0x4;
|
||||
static const uint8_t Z_POSITIVE = 0x5;
|
||||
static const uint8_t Z_NEGATIVE = 0x6;
|
||||
} // namespace SELF_TEST_AXIS
|
||||
} // namespace CC
|
||||
|
||||
namespace SELF_TEST_STEPS {
|
||||
static const uint8_t INIT = 0x0;
|
||||
static const uint8_t X_POSITIVE = 0x1;
|
||||
static const uint8_t X_NEGATIVE = 0x2;
|
||||
static const uint8_t Y_POSITIVE = 0x3;
|
||||
static const uint8_t Y_NEGATIVE = 0x4;
|
||||
static const uint8_t Z_POSITIVE = 0x5;
|
||||
static const uint8_t Z_NEGATIVE = 0x6;
|
||||
static const uint8_t FINA = 0x7;
|
||||
} // namespace SELF_TEST_STEPS
|
||||
size_t getReplySize(CC::CC cc, size_t* optSecondSize = nullptr);
|
||||
|
||||
namespace mode {
|
||||
enum Mode : uint8_t { IDLE = 0, SELF_TEST = 1, DETUMBLE = 2 };
|
||||
}
|
||||
|
||||
namespace selfTest {
|
||||
|
||||
enum Axis : uint8_t {
|
||||
|
||||
ALL = 0x0,
|
||||
X_POSITIVE = 0x1,
|
||||
X_NEGATIVE = 0x2,
|
||||
Y_POSITIVE = 0x3,
|
||||
Y_NEGATIVE = 0x4,
|
||||
Z_POSITIVE = 0x5,
|
||||
Z_NEGATIVE = 0x6,
|
||||
};
|
||||
|
||||
namespace step {
|
||||
|
||||
enum Step : uint8_t {
|
||||
|
||||
INIT = 0x0,
|
||||
X_POSITIVE = 0x1,
|
||||
X_NEGATIVE = 0x2,
|
||||
Y_POSITIVE = 0x3,
|
||||
Y_NEGATIVE = 0x4,
|
||||
Z_POSITIVE = 0x5,
|
||||
Z_NEGATIVE = 0x6,
|
||||
FINA = 0x7
|
||||
};
|
||||
}
|
||||
} // namespace selfTest
|
||||
|
||||
enum PoolIds : lp_id_t {
|
||||
STATUS_BYTE_MODE,
|
||||
STATUS_BYTE_ERROR,
|
||||
STATUS_BYTE_CONF,
|
||||
STATUS_BYTE_UPTIME,
|
||||
|
||||
DIGITAL_VOLTAGE_MV,
|
||||
ANALOG_VOLTAGE_MV,
|
||||
DIGITAL_CURRENT,
|
||||
@ -384,12 +464,23 @@ enum PoolIds : lp_id_t {
|
||||
FINA_NEG_Z_COIL_Z_TEMPERATURE,
|
||||
};
|
||||
|
||||
class EngHkDataset : public StaticLocalDataSet<ENG_HK_SET_POOL_ENTRIES> {
|
||||
class StatusDataset : public StaticLocalDataSet<4> {
|
||||
public:
|
||||
EngHkDataset(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, IMTQ::SetIds::ENG_HK) {}
|
||||
StatusDataset(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, imtq::SetIds::STATUS_SET) {}
|
||||
// Status byte variables
|
||||
lp_var_t<uint8_t> statusByteMode = lp_var_t<uint8_t>(sid.objectId, STATUS_BYTE_MODE, this);
|
||||
lp_var_t<uint8_t> statusByteError = lp_var_t<uint8_t>(sid.objectId, STATUS_BYTE_ERROR, this);
|
||||
lp_var_t<uint8_t> statusByteConfig = lp_var_t<uint8_t>(sid.objectId, STATUS_BYTE_CONF, this);
|
||||
lp_var_t<uint32_t> statusByteUptime = lp_var_t<uint32_t>(sid.objectId, STATUS_BYTE_UPTIME, this);
|
||||
};
|
||||
|
||||
EngHkDataset(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::ENG_HK)) {}
|
||||
class HkDataset : public StaticLocalDataSet<HK_SET_POOL_ENTRIES> {
|
||||
public:
|
||||
HkDataset(HasLocalDataPoolIF* owner, uint32_t setId) : StaticLocalDataSet(owner, setId) {}
|
||||
|
||||
HkDataset(object_id_t objectId, uint32_t setId) : StaticLocalDataSet(sid_t(objectId, setId)) {}
|
||||
|
||||
// Engineering HK variables
|
||||
lp_var_t<uint16_t> digitalVoltageMv = lp_var_t<uint16_t>(sid.objectId, DIGITAL_VOLTAGE_MV, this);
|
||||
lp_var_t<uint16_t> analogVoltageMv = lp_var_t<uint16_t>(sid.objectId, ANALOG_VOLTAGE_MV, this);
|
||||
lp_var_t<float> digitalCurrentmA = lp_var_t<float>(sid.objectId, DIGITAL_CURRENT, this);
|
||||
@ -404,16 +495,27 @@ class EngHkDataset : public StaticLocalDataSet<ENG_HK_SET_POOL_ENTRIES> {
|
||||
lp_var_t<int16_t> mcuTemperature = lp_var_t<int16_t>(sid.objectId, MCU_TEMPERATURE, this);
|
||||
};
|
||||
|
||||
class HkDatasetNoTorque : public HkDataset {
|
||||
public:
|
||||
HkDatasetNoTorque(HasLocalDataPoolIF* owner) : HkDataset(owner, imtq::SetIds::ENG_HK_NO_TORQUE) {}
|
||||
};
|
||||
|
||||
class HkDatasetWithTorque : public HkDataset {
|
||||
public:
|
||||
HkDatasetWithTorque(HasLocalDataPoolIF* owner)
|
||||
: HkDataset(owner, imtq::SetIds::ENG_HK_SET_WITH_TORQUE) {}
|
||||
};
|
||||
/**
|
||||
*
|
||||
* @brief This dataset holds the last calibrated MTM measurement.
|
||||
*/
|
||||
class CalibratedMtmMeasurementSet : public StaticLocalDataSet<CAL_MTM_POOL_ENTRIES> {
|
||||
public:
|
||||
CalibratedMtmMeasurementSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::CAL_MGM) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::CAL_MTM_SET) {}
|
||||
|
||||
CalibratedMtmMeasurementSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::CAL_MGM)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::CAL_MTM_SET)) {}
|
||||
|
||||
/** The unit of all measurements is nT */
|
||||
lp_vec_t<int32_t, 3> mgmXyz = lp_vec_t<int32_t, 3>(sid.objectId, MGM_CAL_NT, this);
|
||||
@ -427,11 +529,11 @@ class CalibratedMtmMeasurementSet : public StaticLocalDataSet<CAL_MTM_POOL_ENTRI
|
||||
*/
|
||||
class RawMtmMeasurementSet : public StaticLocalDataSet<CAL_MTM_POOL_ENTRIES> {
|
||||
public:
|
||||
RawMtmMeasurementSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::RAW_MGM) {}
|
||||
RawMtmMeasurementSet(HasLocalDataPoolIF* owner, uint32_t setId)
|
||||
: StaticLocalDataSet(owner, setId) {}
|
||||
|
||||
RawMtmMeasurementSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::RAW_MGM)) {}
|
||||
RawMtmMeasurementSet(object_id_t objectId, uint32_t setId)
|
||||
: StaticLocalDataSet(sid_t(objectId, setId)) {}
|
||||
|
||||
/** The unit of all measurements is nT */
|
||||
lp_vec_t<float, 3> mtmRawNt = lp_vec_t<float, 3>(sid.objectId, MTM_RAW, this);
|
||||
@ -440,6 +542,21 @@ class RawMtmMeasurementSet : public StaticLocalDataSet<CAL_MTM_POOL_ENTRIES> {
|
||||
lp_var_t<uint8_t>(sid.objectId, ACTUATION_RAW_STATUS, this);
|
||||
};
|
||||
|
||||
class RawMtmMeasurementNoTorque : public RawMtmMeasurementSet {
|
||||
public:
|
||||
RawMtmMeasurementNoTorque(HasLocalDataPoolIF* owner)
|
||||
: RawMtmMeasurementSet(owner, imtq::SetIds::RAW_MTM_NO_TORQUE) {}
|
||||
RawMtmMeasurementNoTorque(object_id_t objectId)
|
||||
: RawMtmMeasurementSet(objectId, imtq::SetIds::RAW_MTM_NO_TORQUE) {}
|
||||
};
|
||||
class RawMtmMeasurementWithTorque : public RawMtmMeasurementSet {
|
||||
public:
|
||||
RawMtmMeasurementWithTorque(HasLocalDataPoolIF* owner)
|
||||
: RawMtmMeasurementSet(owner, imtq::SetIds::RAW_MTM_WITH_TORQUE) {}
|
||||
RawMtmMeasurementWithTorque(object_id_t objectId)
|
||||
: RawMtmMeasurementSet(objectId, imtq::SetIds::RAW_MTM_WITH_TORQUE) {}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief This class can be used to ease the generation of an action message commanding the
|
||||
* IMTQHandler to configure the magnettorquer with the desired dipoles.
|
||||
@ -482,9 +599,9 @@ class DipoleActuationSet : public StaticLocalDataSet<4> {
|
||||
|
||||
public:
|
||||
DipoleActuationSet(HasLocalDataPoolIF& owner)
|
||||
: StaticLocalDataSet(&owner, IMTQ::SetIds::DIPOLES) {}
|
||||
: StaticLocalDataSet(&owner, imtq::SetIds::DIPOLES) {}
|
||||
DipoleActuationSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::DIPOLES)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::DIPOLES)) {}
|
||||
|
||||
// Refresh torque command without changing any of the set dipoles.
|
||||
void refreshTorqueing(uint16_t durationMs_) { currentTorqueDurationMs = durationMs_; }
|
||||
@ -534,10 +651,10 @@ class DipoleActuationSet : public StaticLocalDataSet<4> {
|
||||
class PosXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
PosXSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::POS_X_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::POSITIVE_X_TEST) {}
|
||||
|
||||
PosXSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::POS_X_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::POSITIVE_X_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_POS_X_ERR, this);
|
||||
@ -611,10 +728,10 @@ class PosXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
class NegXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
NegXSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::NEG_X_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::NEGATIVE_X_TEST) {}
|
||||
|
||||
NegXSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::NEG_X_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::NEGATIVE_X_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_NEG_X_ERR, this);
|
||||
@ -688,10 +805,10 @@ class NegXSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
class PosYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
PosYSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::POS_Y_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::POSITIVE_Y_TEST) {}
|
||||
|
||||
PosYSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::POS_Y_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::POSITIVE_Y_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_POS_Y_ERR, this);
|
||||
@ -765,10 +882,10 @@ class PosYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
class NegYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
NegYSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::NEG_Y_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::NEGATIVE_Y_TEST) {}
|
||||
|
||||
NegYSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::NEG_Y_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::NEGATIVE_Y_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_NEG_Y_ERR, this);
|
||||
@ -842,10 +959,10 @@ class NegYSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
class PosZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
PosZSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::POS_Z_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::POSITIVE_Z_TEST) {}
|
||||
|
||||
PosZSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::POS_Z_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::POSITIVE_Y_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_POS_Z_ERR, this);
|
||||
@ -919,10 +1036,10 @@ class PosZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
class NegZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
public:
|
||||
NegZSelfTestSet(HasLocalDataPoolIF* owner)
|
||||
: StaticLocalDataSet(owner, IMTQ::SetIds::NEG_Z_TEST) {}
|
||||
: StaticLocalDataSet(owner, imtq::SetIds::NEGATIVE_Z_TEST) {}
|
||||
|
||||
NegZSelfTestSet(object_id_t objectId)
|
||||
: StaticLocalDataSet(sid_t(objectId, IMTQ::SetIds::NEG_Z_TEST)) {}
|
||||
: StaticLocalDataSet(sid_t(objectId, imtq::SetIds::NEGATIVE_Z_TEST)) {}
|
||||
|
||||
/** INIT block */
|
||||
lp_var_t<uint8_t> initErr = lp_var_t<uint8_t>(sid.objectId, INIT_NEG_Z_ERR, this);
|
||||
@ -979,6 +1096,153 @@ class NegZSelfTestSet : public StaticLocalDataSet<SELF_TEST_DATASET_ENTRIES> {
|
||||
lp_var_t<int16_t>(sid.objectId, FINA_NEG_Z_COIL_Z_TEMPERATURE, this);
|
||||
};
|
||||
|
||||
} // namespace IMTQ
|
||||
} // namespace imtq
|
||||
|
||||
struct ImtqRequest {
|
||||
friend class ImtqHandler;
|
||||
|
||||
public:
|
||||
static constexpr size_t REQUEST_LEN = 10;
|
||||
|
||||
ImtqRequest(const uint8_t* data, size_t maxSize)
|
||||
: rawData(const_cast<uint8_t*>(data)), maxSize(maxSize) {}
|
||||
|
||||
imtq::RequestType getRequestType() const { return static_cast<imtq::RequestType>(rawData[0]); }
|
||||
|
||||
void setMeasureRequest(imtq::SpecialRequest specialRequest) {
|
||||
rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_NO_ACTUATION);
|
||||
rawData[1] = static_cast<uint8_t>(specialRequest);
|
||||
}
|
||||
|
||||
void setActuateRequest(int16_t dipoleX, int16_t dipoleY, int16_t dipoleZ,
|
||||
uint16_t torqueDuration) {
|
||||
size_t dummy = 0;
|
||||
rawData[0] = static_cast<uint8_t>(imtq::RequestType::ACTUATE);
|
||||
rawData[1] = static_cast<uint8_t>(imtq::SpecialRequest::NONE);
|
||||
uint8_t* serPtr = rawData + 2;
|
||||
SerializeAdapter::serialize(&dipoleX, &serPtr, &dummy, maxSize,
|
||||
SerializeIF::Endianness::MACHINE);
|
||||
SerializeAdapter::serialize(&dipoleY, &serPtr, &dummy, maxSize,
|
||||
SerializeIF::Endianness::MACHINE);
|
||||
SerializeAdapter::serialize(&dipoleZ, &serPtr, &dummy, maxSize,
|
||||
SerializeIF::Endianness::MACHINE);
|
||||
SerializeAdapter::serialize(&torqueDuration, &serPtr, &dummy, maxSize,
|
||||
SerializeIF::Endianness::MACHINE);
|
||||
}
|
||||
|
||||
uint8_t* startOfActuateDataPtr() { return rawData + 2; }
|
||||
|
||||
int16_t* getDipoles() { return reinterpret_cast<int16_t*>(rawData + 2); }
|
||||
|
||||
uint16_t getTorqueDuration() {
|
||||
uint8_t* data = rawData + 2 + 6;
|
||||
uint16_t value = 0;
|
||||
size_t dummy = 0;
|
||||
SerializeAdapter::deSerialize(&value, data, &dummy, SerializeIF::Endianness::MACHINE);
|
||||
return value;
|
||||
}
|
||||
|
||||
void setSpecialRequest(imtq::SpecialRequest specialRequest) {
|
||||
rawData[1] = static_cast<uint8_t>(specialRequest);
|
||||
}
|
||||
|
||||
imtq::SpecialRequest getSpecialRequest() const {
|
||||
return static_cast<imtq::SpecialRequest>(rawData[1]);
|
||||
}
|
||||
|
||||
private:
|
||||
ImtqRequest(uint8_t* rawData, size_t maxLen) : rawData(rawData) {
|
||||
if (rawData != nullptr) {
|
||||
rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_NO_ACTUATION);
|
||||
}
|
||||
}
|
||||
uint8_t* rawData;
|
||||
size_t maxSize = 0;
|
||||
};
|
||||
|
||||
struct ImtqRepliesDefault {
|
||||
friend class ImtqPollingTask;
|
||||
|
||||
public:
|
||||
static constexpr size_t BASE_LEN =
|
||||
imtq::replySize::DEFAULT_MIN_LEN + 1 + imtq::replySize::SYSTEM_STATE + 1 +
|
||||
+imtq::replySize::DEFAULT_MIN_LEN + 1 + imtq::replySize::RAW_MTM_MEASUREMENT + 1 +
|
||||
imtq::replySize::ENG_HK_DATA_REPLY + 1 + imtq::replySize::CAL_MTM_MEASUREMENT + 1;
|
||||
ImtqRepliesDefault(const uint8_t* rawData) : rawData(const_cast<uint8_t*>(rawData)) {
|
||||
initPointers();
|
||||
}
|
||||
|
||||
uint8_t* getCalibMgmMeasurement() const { return calibMgmMeasurement + 1; }
|
||||
bool wasCalibMgmMeasurementRead() const { return calibMgmMeasurement[0]; };
|
||||
|
||||
uint8_t* getEngHk() const { return engHk + 1; }
|
||||
bool wasEngHkRead() const { return engHk[0]; };
|
||||
|
||||
uint8_t* getRawMgmMeasurement() const { return rawMgmMeasurement + 1; }
|
||||
bool wasGetRawMgmMeasurementRead() const { return rawMgmMeasurement[0]; };
|
||||
|
||||
uint8_t* getSpecialRequest() const { return specialRequestReply + 1; }
|
||||
bool wasSpecialRequestRead() const { return specialRequestReply[0]; }
|
||||
uint8_t* getStartMtmMeasurement() const { return startMtmMeasurement + 1; }
|
||||
bool wasStartMtmMeasurementRead() const { return startMtmMeasurement[0]; }
|
||||
|
||||
uint8_t* getSwReset() const { return swReset + 1; }
|
||||
|
||||
uint8_t* getSystemState() const { return systemState + 1; }
|
||||
bool wasGetSystemStateRead() const { return systemState[0]; }
|
||||
|
||||
private:
|
||||
void initPointers() {
|
||||
swReset = rawData;
|
||||
systemState = swReset + imtq::replySize::DEFAULT_MIN_LEN + 1;
|
||||
startMtmMeasurement = systemState + imtq::replySize::SYSTEM_STATE + 1;
|
||||
rawMgmMeasurement = startMtmMeasurement + imtq::replySize::DEFAULT_MIN_LEN + 1;
|
||||
engHk = rawMgmMeasurement + imtq::replySize::RAW_MTM_MEASUREMENT + 1;
|
||||
calibMgmMeasurement = engHk + imtq::replySize::ENG_HK_DATA_REPLY + 1;
|
||||
specialRequestReply = calibMgmMeasurement + imtq::replySize::CAL_MTM_MEASUREMENT + 1;
|
||||
}
|
||||
uint8_t* rawData;
|
||||
uint8_t* swReset;
|
||||
uint8_t* systemState;
|
||||
uint8_t* startMtmMeasurement;
|
||||
uint8_t* rawMgmMeasurement;
|
||||
uint8_t* engHk;
|
||||
uint8_t* calibMgmMeasurement;
|
||||
// Share this to reduce amount of copied code for each transfer.
|
||||
uint8_t* specialRequestReply;
|
||||
};
|
||||
|
||||
struct ImtqRepliesWithTorque {
|
||||
friend class ImtqPollingTask;
|
||||
|
||||
public:
|
||||
static constexpr size_t BASE_LEN =
|
||||
imtq::replySize::DEFAULT_MIN_LEN + 1 + imtq::replySize::ENG_HK_DATA_REPLY + 1 +
|
||||
imtq::replySize::DEFAULT_MIN_LEN + 1 + imtq::replySize::RAW_MTM_MEASUREMENT + 1;
|
||||
ImtqRepliesWithTorque(const uint8_t* rawData) : rawData(const_cast<uint8_t*>(rawData)) {
|
||||
initPointers();
|
||||
}
|
||||
|
||||
uint8_t* getDipoleActuation() const { return dipoleActuation + 1; }
|
||||
bool wasDipoleActuationRead() const { return dipoleActuation[0]; }
|
||||
|
||||
uint8_t* getEngHk() const { return engHk + 1; }
|
||||
bool wasEngHkRead() const { return engHk[0]; };
|
||||
|
||||
uint8_t* getRawMgmMeasurement() const { return rawMgmMeasurement + 1; }
|
||||
bool wasGetRawMgmMeasurementRead() const { return rawMgmMeasurement[0]; };
|
||||
|
||||
private:
|
||||
void initPointers() {
|
||||
dipoleActuation = rawData;
|
||||
engHk = dipoleActuation + imtq::replySize::DEFAULT_MIN_LEN + 1;
|
||||
startMtmMeasurement = engHk + imtq::replySize::ENG_HK_DATA_REPLY + 1;
|
||||
rawMgmMeasurement = startMtmMeasurement + imtq::replySize::DEFAULT_MIN_LEN + 1;
|
||||
}
|
||||
uint8_t* rawData;
|
||||
uint8_t* dipoleActuation;
|
||||
uint8_t* engHk;
|
||||
uint8_t* startMtmMeasurement;
|
||||
uint8_t* rawMgmMeasurement;
|
||||
};
|
||||
#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_IMTQDEFINITIONS_H_ */
|
||||
@ -52,6 +52,7 @@ ReturnValue_t CfdpTmFunnel::handlePacket(TmTcMessage& msg) {
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t packetLen = 0;
|
||||
uint8_t* serPtr = newPacketData;
|
||||
result = spacePacketHeader.serializeBe(&serPtr, &packetLen, spacePacketHeader.getFullPacketLen());
|
||||
@ -83,8 +84,8 @@ ReturnValue_t CfdpTmFunnel::handlePacket(TmTcMessage& msg) {
|
||||
sif::error << "PusTmFunnel::handlePacket: Store too full to create data copy or store "
|
||||
"error"
|
||||
<< std::endl;
|
||||
break;
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
msg.setStorageId(origStoreId);
|
||||
|
||||
Reference in New Issue
Block a user