eive-obsw/mission/controller/acs/AcsParameters.cpp

812 lines
28 KiB
C++
Raw Normal View History

2022-09-16 14:13:41 +02:00
#include "AcsParameters.h"
#include <fsfw/src/fsfw/globalfunctions/constants.h>
#include <stddef.h>
AcsParameters::AcsParameters() {}
2022-09-16 14:13:41 +02:00
AcsParameters::~AcsParameters() {}
ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
ParameterWrapper* parameterWrapper,
const ParameterWrapper* newValues,
uint16_t startAtIndex) {
switch (domainId) {
case 0x0: // direct members
switch (parameterId) {
default:
return INVALID_IDENTIFIER_ID;
}
break;
case 0x1: // OnBoardParams
switch (parameterId) {
case 0x0:
parameterWrapper->set(onBoardParams.sampleTime);
break;
2023-03-14 13:15:48 +01:00
case 0x1:
2023-11-15 16:54:54 +01:00
parameterWrapper->set(onBoardParams.ptgCtrlLostTimer);
2023-03-14 13:15:48 +01:00
break;
case 0x2:
parameterWrapper->set(onBoardParams.fusedRateSafeDuringEclipse);
break;
2023-11-23 16:56:36 +01:00
case 0x3:
parameterWrapper->set(onBoardParams.fusedRateFromStr);
break;
case 0x4:
parameterWrapper->set(onBoardParams.fusedRateFromQuest);
break;
2023-11-27 10:52:30 +01:00
case 0x5:
parameterWrapper->set(onBoardParams.questFilterWeight);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case 0x2: // InertiaEIVE
switch (parameterId) {
case 0x0:
parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixDeployed);
break;
2023-04-06 11:15:50 +02:00
case 0x1:
parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixUndeployed);
break;
2023-04-06 11:15:50 +02:00
case 0x2:
parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixPanel1);
break;
2023-04-06 11:15:50 +02:00
case 0x3:
parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixPanel3);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case 0x3: // MgmHandlingParameters
switch (parameterId) {
case 0x0:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm0orientationMatrix);
break;
case 0x1:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm1orientationMatrix);
break;
case 0x2:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm2orientationMatrix);
break;
case 0x3:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm3orientationMatrix);
break;
case 0x4:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm4orientationMatrix);
break;
case 0x5:
parameterWrapper->setVector(mgmHandlingParameters.mgm0hardIronOffset);
break;
case 0x6:
parameterWrapper->setVector(mgmHandlingParameters.mgm1hardIronOffset);
break;
case 0x7:
parameterWrapper->setVector(mgmHandlingParameters.mgm2hardIronOffset);
break;
case 0x8:
parameterWrapper->setVector(mgmHandlingParameters.mgm3hardIronOffset);
break;
case 0x9:
parameterWrapper->setVector(mgmHandlingParameters.mgm4hardIronOffset);
break;
case 0xA:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm0softIronInverse);
break;
case 0xB:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm1softIronInverse);
break;
case 0xC:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm2softIronInverse);
break;
case 0xD:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm3softIronInverse);
break;
case 0xE:
parameterWrapper->setMatrix(mgmHandlingParameters.mgm4softIronInverse);
break;
case 0xF:
parameterWrapper->setVector(mgmHandlingParameters.mgm02variance);
break;
case 0x10:
parameterWrapper->setVector(mgmHandlingParameters.mgm13variance);
break;
case 0x11:
parameterWrapper->setVector(mgmHandlingParameters.mgm4variance);
break;
2023-04-06 11:15:50 +02:00
case 0x12:
2023-07-19 11:47:23 +02:00
parameterWrapper->set(mgmHandlingParameters.mgmVectorFilterWeight);
break;
case 0x13:
2023-04-06 11:15:50 +02:00
parameterWrapper->set(mgmHandlingParameters.mgmDerivativeFilterWeight);
break;
case 0x14:
parameterWrapper->set(mgmHandlingParameters.useMgm4);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case 0x4: // SusHandlingParameters
switch (parameterId) {
case 0x0:
parameterWrapper->setMatrix(susHandlingParameters.sus0orientationMatrix);
break;
case 0x1:
parameterWrapper->setMatrix(susHandlingParameters.sus1orientationMatrix);
break;
case 0x2:
parameterWrapper->setMatrix(susHandlingParameters.sus2orientationMatrix);
break;
case 0x3:
parameterWrapper->setMatrix(susHandlingParameters.sus3orientationMatrix);
break;
case 0x4:
parameterWrapper->setMatrix(susHandlingParameters.sus4orientationMatrix);
break;
case 0x5:
parameterWrapper->setMatrix(susHandlingParameters.sus5orientationMatrix);
break;
case 0x6:
parameterWrapper->setMatrix(susHandlingParameters.sus6orientationMatrix);
break;
case 0x7:
parameterWrapper->setMatrix(susHandlingParameters.sus7orientationMatrix);
break;
case 0x8:
parameterWrapper->setMatrix(susHandlingParameters.sus8orientationMatrix);
break;
case 0x9:
parameterWrapper->setMatrix(susHandlingParameters.sus9orientationMatrix);
break;
case 0xA:
parameterWrapper->setMatrix(susHandlingParameters.sus10orientationMatrix);
break;
case 0xB:
parameterWrapper->setMatrix(susHandlingParameters.sus11orientationMatrix);
break;
case 0xC:
parameterWrapper->setMatrix(susHandlingParameters.sus0coeffAlpha);
break;
case 0xD:
parameterWrapper->setMatrix(susHandlingParameters.sus0coeffBeta);
break;
case 0xE:
parameterWrapper->setMatrix(susHandlingParameters.sus1coeffAlpha);
break;
case 0xF:
parameterWrapper->setMatrix(susHandlingParameters.sus1coeffBeta);
break;
case 0x10:
parameterWrapper->setMatrix(susHandlingParameters.sus2coeffAlpha);
break;
case 0x11:
parameterWrapper->setMatrix(susHandlingParameters.sus2coeffBeta);
break;
case 0x12:
parameterWrapper->setMatrix(susHandlingParameters.sus3coeffAlpha);
break;
case 0x13:
parameterWrapper->setMatrix(susHandlingParameters.sus3coeffBeta);
break;
case 0x14:
parameterWrapper->setMatrix(susHandlingParameters.sus4coeffAlpha);
break;
case 0x15:
parameterWrapper->setMatrix(susHandlingParameters.sus4coeffBeta);
break;
case 0x16:
parameterWrapper->setMatrix(susHandlingParameters.sus5coeffAlpha);
break;
case 0x17:
parameterWrapper->setMatrix(susHandlingParameters.sus5coeffBeta);
break;
case 0x18:
parameterWrapper->setMatrix(susHandlingParameters.sus6coeffAlpha);
break;
case 0x19:
parameterWrapper->setMatrix(susHandlingParameters.sus6coeffBeta);
break;
case 0x1A:
parameterWrapper->setMatrix(susHandlingParameters.sus7coeffAlpha);
break;
case 0x1B:
parameterWrapper->setMatrix(susHandlingParameters.sus7coeffBeta);
break;
case 0x1C:
parameterWrapper->setMatrix(susHandlingParameters.sus8coeffAlpha);
break;
case 0x1D:
parameterWrapper->setMatrix(susHandlingParameters.sus8coeffBeta);
break;
case 0x1E:
parameterWrapper->setMatrix(susHandlingParameters.sus9coeffAlpha);
break;
case 0x1F:
parameterWrapper->setMatrix(susHandlingParameters.sus9coeffBeta);
break;
case 0x20:
parameterWrapper->setMatrix(susHandlingParameters.sus10coeffAlpha);
break;
case 0x21:
parameterWrapper->setMatrix(susHandlingParameters.sus10coeffBeta);
break;
case 0x22:
parameterWrapper->setMatrix(susHandlingParameters.sus11coeffAlpha);
break;
case 0x23:
parameterWrapper->setMatrix(susHandlingParameters.sus11coeffBeta);
break;
2023-06-19 16:22:32 +02:00
case 0x24:
parameterWrapper->set(susHandlingParameters.susBrightnessThreshold);
2023-06-19 17:08:05 +02:00
break;
2023-07-19 11:47:23 +02:00
case 0x25:
parameterWrapper->set(susHandlingParameters.susVectorFilterWeight);
break;
case 0x26:
parameterWrapper->set(susHandlingParameters.susRateFilterWeight);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0x5): // GyrHandlingParameters
switch (parameterId) {
case 0x0:
parameterWrapper->setMatrix(gyrHandlingParameters.gyr0orientationMatrix);
break;
case 0x1:
parameterWrapper->setMatrix(gyrHandlingParameters.gyr1orientationMatrix);
break;
case 0x2:
parameterWrapper->setMatrix(gyrHandlingParameters.gyr2orientationMatrix);
break;
case 0x3:
parameterWrapper->setMatrix(gyrHandlingParameters.gyr3orientationMatrix);
break;
case 0x4:
parameterWrapper->setVector(gyrHandlingParameters.gyr0bias);
break;
case 0x5:
parameterWrapper->setVector(gyrHandlingParameters.gyr1bias);
break;
case 0x6:
parameterWrapper->setVector(gyrHandlingParameters.gyr2bias);
break;
case 0x7:
parameterWrapper->setVector(gyrHandlingParameters.gyr3bias);
break;
case 0x8:
parameterWrapper->setVector(gyrHandlingParameters.gyr02variance);
break;
case 0x9:
parameterWrapper->setVector(gyrHandlingParameters.gyr13variance);
break;
case 0xA:
parameterWrapper->set(gyrHandlingParameters.preferAdis);
break;
2023-04-06 11:15:50 +02:00
case 0xB:
parameterWrapper->set(gyrHandlingParameters.gyrFilterWeight);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0x6): // RwHandlingParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(rwHandlingParameters.inertiaWheel);
break;
case 0x1:
parameterWrapper->set(rwHandlingParameters.maxTrq);
break;
case 0x2:
parameterWrapper->set(rwHandlingParameters.maxRwSpeed);
break;
case 0x3:
parameterWrapper->set(rwHandlingParameters.stictionSpeed);
break;
case 0x4:
parameterWrapper->set(rwHandlingParameters.stictionReleaseSpeed);
break;
case 0x5:
parameterWrapper->set(rwHandlingParameters.stictionTorque);
break;
case 0x6:
parameterWrapper->set(rwHandlingParameters.rampTime);
2023-02-10 13:29:13 +01:00
break;
2023-06-05 09:43:31 +02:00
case 0x7:
parameterWrapper->set(rwHandlingParameters.multipleRwInvalidTimeout);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0x7): // RwMatrices
switch (parameterId) {
case 0x0:
parameterWrapper->setMatrix(rwMatrices.alignmentMatrix);
break;
case 0x1:
parameterWrapper->setMatrix(rwMatrices.pseudoInverse);
break;
case 0x2:
parameterWrapper->setMatrix(rwMatrices.pseudoInverseWithoutRW1);
break;
case 0x3:
parameterWrapper->setMatrix(rwMatrices.pseudoInverseWithoutRW2);
break;
case 0x4:
parameterWrapper->setMatrix(rwMatrices.pseudoInverseWithoutRW3);
break;
case 0x5:
parameterWrapper->setMatrix(rwMatrices.pseudoInverseWithoutRW4);
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(rwMatrices.nullspaceVector);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0x8): // SafeModeControllerParameters
switch (parameterId) {
case 0x0:
2023-03-24 14:51:07 +01:00
parameterWrapper->set(safeModeControllerParameters.k_orthoMekf);
break;
case 0x1:
2023-03-24 14:51:07 +01:00
parameterWrapper->set(safeModeControllerParameters.k_alignMekf);
break;
case 0x2:
2023-03-24 14:51:07 +01:00
parameterWrapper->set(safeModeControllerParameters.k_parallelMekf);
break;
case 0x3:
2023-07-19 14:41:09 +02:00
parameterWrapper->set(safeModeControllerParameters.k_orthoGyr);
break;
case 0x4:
2023-07-19 14:41:09 +02:00
parameterWrapper->set(safeModeControllerParameters.k_alignGyr);
break;
case 0x5:
2023-07-19 14:41:09 +02:00
parameterWrapper->set(safeModeControllerParameters.k_parallelGyr);
break;
case 0x6:
2023-07-25 09:55:34 +02:00
parameterWrapper->set(safeModeControllerParameters.k_orthoSusMgm);
break;
case 0x7:
2023-07-25 09:55:34 +02:00
parameterWrapper->set(safeModeControllerParameters.k_alignSusMgm);
2023-03-22 08:59:13 +01:00
break;
case 0x8:
2023-07-25 09:55:34 +02:00
parameterWrapper->set(safeModeControllerParameters.k_parallelSusMgm);
break;
2023-04-13 14:29:24 +02:00
case 0x9:
2023-07-19 14:41:09 +02:00
parameterWrapper->setVector(safeModeControllerParameters.sunTargetDirLeop);
break;
case 0xA:
parameterWrapper->setVector(safeModeControllerParameters.sunTargetDir);
break;
case 0xB:
parameterWrapper->set(safeModeControllerParameters.useMekf);
break;
case 0xC:
parameterWrapper->set(safeModeControllerParameters.useGyr);
break;
case 0xD:
2023-04-06 13:34:52 +02:00
parameterWrapper->set(safeModeControllerParameters.dampingDuringEclipse);
2023-03-22 08:59:13 +01:00
break;
2023-07-19 16:34:02 +02:00
case 0xE:
parameterWrapper->set(safeModeControllerParameters.sineLimitSunRotRate);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0x9): // IdleModeControllerParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(idleModeControllerParameters.zeta);
2023-02-20 16:35:48 +01:00
break;
case 0x1:
parameterWrapper->set(idleModeControllerParameters.om);
2023-02-20 16:35:48 +01:00
break;
case 0x2:
parameterWrapper->set(idleModeControllerParameters.omMax);
2023-02-20 16:35:48 +01:00
break;
case 0x3:
parameterWrapper->set(idleModeControllerParameters.qiMin);
2023-02-20 16:35:48 +01:00
break;
case 0x4:
parameterWrapper->set(idleModeControllerParameters.gainNullspace);
2023-02-20 16:35:48 +01:00
break;
case 0x5:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(idleModeControllerParameters.nullspaceSpeed);
2023-02-20 16:35:48 +01:00
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(idleModeControllerParameters.desatMomentumRef);
2023-02-20 16:35:48 +01:00
break;
case 0x7:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(idleModeControllerParameters.deSatGainFactor);
2023-02-20 16:35:48 +01:00
break;
case 0x8:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(idleModeControllerParameters.desatOn);
break;
case 0x9:
parameterWrapper->set(idleModeControllerParameters.enableAntiStiction);
2023-02-20 16:35:48 +01:00
break;
2023-11-24 11:30:27 +01:00
case 0xA:
parameterWrapper->set(idleModeControllerParameters.useMekf);
break;
2023-02-20 16:35:48 +01:00
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0xA): // TargetModeControllerParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(targetModeControllerParameters.zeta);
break;
case 0x1:
parameterWrapper->set(targetModeControllerParameters.om);
break;
case 0x2:
parameterWrapper->set(targetModeControllerParameters.omMax);
break;
case 0x3:
parameterWrapper->set(targetModeControllerParameters.qiMin);
break;
case 0x4:
parameterWrapper->set(targetModeControllerParameters.gainNullspace);
break;
case 0x5:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(targetModeControllerParameters.nullspaceSpeed);
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(targetModeControllerParameters.desatMomentumRef);
break;
case 0x7:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(targetModeControllerParameters.deSatGainFactor);
break;
case 0x8:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(targetModeControllerParameters.desatOn);
break;
case 0x9:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(targetModeControllerParameters.enableAntiStiction);
break;
case 0xA:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.useMekf);
break;
case 0xB:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(targetModeControllerParameters.refDirection);
break;
case 0xC:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(targetModeControllerParameters.refRotRate);
break;
case 0xD:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(targetModeControllerParameters.quatRef);
break;
case 0xE:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.timeElapsedMax);
break;
case 0xF:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.latitudeTgt);
break;
case 0x10:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.longitudeTgt);
break;
case 0x11:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.altitudeTgt);
break;
case 0x12:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.avoidBlindStr);
break;
case 0x13:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.blindAvoidStart);
2023-04-27 13:52:41 +02:00
break;
case 0x14:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(targetModeControllerParameters.blindAvoidStop);
break;
case 0x15:
parameterWrapper->set(targetModeControllerParameters.blindRotRate);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0xB): // GsTargetModeControllerParameters
switch (parameterId) {
case 0x0:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.zeta);
2023-02-20 16:35:48 +01:00
break;
case 0x1:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.om);
2023-02-20 16:35:48 +01:00
break;
case 0x2:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.omMax);
2023-02-20 16:35:48 +01:00
break;
case 0x3:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.qiMin);
2023-02-20 16:35:48 +01:00
break;
case 0x4:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.gainNullspace);
2023-02-20 16:35:48 +01:00
break;
case 0x5:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(gsTargetModeControllerParameters.nullspaceSpeed);
2023-02-20 16:35:48 +01:00
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(gsTargetModeControllerParameters.desatMomentumRef);
2023-02-20 16:35:48 +01:00
break;
case 0x7:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(gsTargetModeControllerParameters.deSatGainFactor);
2023-02-20 16:35:48 +01:00
break;
case 0x8:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(gsTargetModeControllerParameters.desatOn);
2023-02-20 16:35:48 +01:00
break;
case 0x9:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(gsTargetModeControllerParameters.enableAntiStiction);
2023-02-20 16:35:48 +01:00
break;
case 0xA:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.useMekf);
2023-02-20 16:35:48 +01:00
break;
case 0xB:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(gsTargetModeControllerParameters.refDirection);
2023-02-20 16:35:48 +01:00
break;
case 0xC:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.timeElapsedMax);
2023-02-20 16:35:48 +01:00
break;
case 0xD:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.latitudeTgt);
2023-04-27 13:52:41 +02:00
break;
case 0xE:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.longitudeTgt);
break;
case 0xF:
2023-02-27 17:05:09 +01:00
parameterWrapper->set(gsTargetModeControllerParameters.altitudeTgt);
2023-02-20 16:35:48 +01:00
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
case (0xC): // NadirModeControllerParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(nadirModeControllerParameters.zeta);
break;
case 0x1:
parameterWrapper->set(nadirModeControllerParameters.om);
break;
case 0x2:
parameterWrapper->set(nadirModeControllerParameters.omMax);
break;
case 0x3:
parameterWrapper->set(nadirModeControllerParameters.qiMin);
break;
case 0x4:
parameterWrapper->set(nadirModeControllerParameters.gainNullspace);
break;
case 0x5:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(nadirModeControllerParameters.nullspaceSpeed);
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(nadirModeControllerParameters.desatMomentumRef);
break;
case 0x7:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(nadirModeControllerParameters.deSatGainFactor);
break;
case 0x8:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(nadirModeControllerParameters.desatOn);
break;
case 0x9:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(nadirModeControllerParameters.enableAntiStiction);
break;
case 0xA:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(nadirModeControllerParameters.useMekf);
2023-04-27 13:52:41 +02:00
break;
case 0xB:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(nadirModeControllerParameters.refDirection);
break;
case 0xC:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(nadirModeControllerParameters.quatRef);
2023-05-23 15:07:23 +02:00
break;
2023-06-01 09:36:34 +02:00
case 0xD:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(nadirModeControllerParameters.refRotRate);
break;
case 0xE:
parameterWrapper->set(nadirModeControllerParameters.timeElapsedMax);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0xD): // InertialModeControllerParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(inertialModeControllerParameters.zeta);
break;
case 0x1:
parameterWrapper->set(inertialModeControllerParameters.om);
break;
case 0x2:
parameterWrapper->set(inertialModeControllerParameters.omMax);
break;
case 0x3:
parameterWrapper->set(inertialModeControllerParameters.qiMin);
break;
case 0x4:
parameterWrapper->set(inertialModeControllerParameters.gainNullspace);
break;
case 0x5:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(inertialModeControllerParameters.nullspaceSpeed);
break;
case 0x6:
2023-04-27 13:52:41 +02:00
parameterWrapper->setVector(inertialModeControllerParameters.desatMomentumRef);
break;
case 0x7:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(inertialModeControllerParameters.deSatGainFactor);
break;
case 0x8:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(inertialModeControllerParameters.desatOn);
break;
case 0x9:
2023-04-27 13:52:41 +02:00
parameterWrapper->set(inertialModeControllerParameters.enableAntiStiction);
break;
case 0xA:
2023-11-24 11:30:27 +01:00
parameterWrapper->set(inertialModeControllerParameters.useMekf);
2023-04-27 13:52:41 +02:00
break;
case 0xB:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(inertialModeControllerParameters.tgtQuat);
break;
case 0xC:
2023-11-24 11:30:27 +01:00
parameterWrapper->setVector(inertialModeControllerParameters.refRotRate);
break;
case 0xD:
parameterWrapper->setVector(inertialModeControllerParameters.quatRef);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0xE): // StrParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(strParameters.exclusionAngle);
break;
case 0x1:
parameterWrapper->setVector(strParameters.boresightAxis);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0xF): // GpsParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(gpsParameters.timeDiffVelocityMax);
break;
case 0x1:
parameterWrapper->set(gpsParameters.minimumFdirAltitude);
break;
case 0x2:
parameterWrapper->set(gpsParameters.maximumFdirAltitude);
break;
case 0x3:
parameterWrapper->set(gpsParameters.fdirAltitude);
break;
2023-08-09 13:42:54 +02:00
case 0x4:
parameterWrapper->set(gpsParameters.useSpg4);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0x10): // SunModelParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(sunModelParameters.domega);
break;
case 0x1:
parameterWrapper->set(sunModelParameters.omega_0);
break;
case 0x2:
parameterWrapper->set(sunModelParameters.m_0);
break;
case 0x3:
parameterWrapper->set(sunModelParameters.dm);
break;
case 0x4:
parameterWrapper->set(sunModelParameters.e);
break;
case 0x5:
parameterWrapper->set(sunModelParameters.e1);
break;
case 0x6:
parameterWrapper->set(sunModelParameters.p1);
break;
case 0x7:
parameterWrapper->set(sunModelParameters.p2);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0x11): // KalmanFilterParameters
switch (parameterId) {
case 0x0:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseSTR);
break;
case 0x1:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseSS);
break;
case 0x2:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseMAG);
break;
case 0x3:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseGYR);
break;
case 0x4:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseArwGYR);
break;
case 0x5:
parameterWrapper->set(kalmanFilterParameters.sensorNoiseBsGYR);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0x12): // MagnetorquesParameter
switch (parameterId) {
case 0x0:
2023-02-27 16:35:32 +01:00
parameterWrapper->setMatrix(magnetorquerParameter.mtq0orientationMatrix);
break;
case 0x1:
2023-02-27 16:35:32 +01:00
parameterWrapper->setMatrix(magnetorquerParameter.mtq1orientationMatrix);
break;
case 0x2:
2023-02-27 16:35:32 +01:00
parameterWrapper->setMatrix(magnetorquerParameter.mtq2orientationMatrix);
break;
case 0x3:
2023-02-27 16:35:32 +01:00
parameterWrapper->setMatrix(magnetorquerParameter.alignmentMatrixMtq);
break;
case 0x4:
2023-02-27 16:35:32 +01:00
parameterWrapper->setMatrix(magnetorquerParameter.inverseAlignment);
break;
case 0x5:
2023-04-27 10:33:43 +02:00
parameterWrapper->set(magnetorquerParameter.dipoleMax);
break;
case 0x6:
2023-02-27 16:35:32 +01:00
parameterWrapper->set(magnetorquerParameter.torqueDuration);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
2023-02-20 16:35:48 +01:00
case (0x13): // DetumbleParameter
switch (parameterId) {
case 0x0:
parameterWrapper->set(detumbleParameter.detumblecounter);
break;
case 0x1:
parameterWrapper->set(detumbleParameter.omegaDetumbleStart);
break;
case 0x2:
parameterWrapper->set(detumbleParameter.omegaDetumbleEnd);
break;
case 0x3:
2023-04-14 11:38:05 +02:00
parameterWrapper->set(detumbleParameter.gainBdot);
break;
case 0x4:
parameterWrapper->set(detumbleParameter.gainFull);
break;
case 0x5:
parameterWrapper->set(detumbleParameter.useFullDetumbleLaw);
break;
default:
return INVALID_IDENTIFIER_ID;
}
break;
default:
return INVALID_DOMAIN_ID;
}
return returnvalue::OK;
}