eive-obsw/mission/controller/acs/control/SafeCtrl.cpp

152 lines
7.0 KiB
C++
Raw Normal View History

2022-09-20 13:46:42 +02:00
#include "SafeCtrl.h"
2022-10-20 11:07:45 +02:00
2022-09-27 11:06:11 +02:00
#include <fsfw/globalfunctions/math/MatrixOperations.h>
#include <fsfw/globalfunctions/math/QuaternionOperations.h>
#include <fsfw/globalfunctions/math/VectorOperations.h>
2022-10-20 11:07:45 +02:00
#include <math.h>
2022-09-27 11:06:11 +02:00
2023-02-28 09:18:44 +01:00
SafeCtrl::SafeCtrl(AcsParameters *acsParameters_) { acsParameters = acsParameters_; }
2022-09-20 13:46:42 +02:00
2022-10-20 11:07:45 +02:00
SafeCtrl::~SafeCtrl() {}
2022-09-20 13:46:42 +02:00
uint8_t SafeCtrl::safeCtrlStrategy(const bool magFieldValid, const ReturnValue_t mekfValid,
const bool satRotRateValid, const bool sunDirValid) {
2023-03-24 11:35:46 +01:00
if (not magFieldValid) {
2023-04-06 10:37:59 +02:00
return acs::SafeModeStrategy::SAFECTRL_NO_MAG_FIELD_FOR_CONTROL;
2023-03-24 11:35:46 +01:00
} else if (mekfValid) {
2023-04-06 10:37:59 +02:00
return acs::SafeModeStrategy::SAFECTRL_ACTIVE_MEKF;
2023-03-24 11:35:46 +01:00
} else if (satRotRateValid and sunDirValid) {
2023-04-06 10:37:59 +02:00
return acs::SafeModeStrategy::SAFECTRL_WITHOUT_MEKF;
2023-03-24 11:35:46 +01:00
} else if (satRotRateValid and not sunDirValid) {
2023-04-06 10:37:59 +02:00
return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING;
2023-03-24 11:35:46 +01:00
} else {
2023-04-06 10:37:59 +02:00
return acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL;
2023-03-24 11:35:46 +01:00
}
}
2023-03-24 14:51:33 +01:00
void SafeCtrl::safeMekf(const double *magFieldB, const double *satRotRateB,
const double *sunDirModelI, const double *quatBI, const double *sunDirRefB,
2023-04-05 16:46:57 +02:00
const double satRotRateRef, const double inertiaMatrix[3][3],
2023-04-05 16:11:28 +02:00
double *magMomB, double &errorAngle) {
2023-03-24 14:51:33 +01:00
// convert magFieldB from uT to T
VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
2022-10-20 11:07:45 +02:00
2023-03-24 14:51:33 +01:00
// convert sunDirModel to body rf
double sunDirB[3] = {0, 0, 0};
QuaternionOperations::multiplyVector(quatBI, sunDirModelI, sunDirB);
2022-10-20 11:07:45 +02:00
2023-03-24 14:51:33 +01:00
// calculate angle alpha between sunDirRef and sunDir
double dotSun = VectorOperations<double>::dot(sunDirRefB, sunDirB);
errorAngle = acos(dotSun);
2022-10-20 11:07:45 +02:00
2023-04-05 16:11:28 +02:00
splitRotationalRate(satRotRateB, sunDirB);
2023-04-05 16:46:57 +02:00
calculateRotationalRateTorque(satRotRateRef, sunDirB, sunDirRefB, errorAngle,
2023-04-05 16:11:28 +02:00
acsParameters->safeModeControllerParameters.k_parallelMekf,
acsParameters->safeModeControllerParameters.k_orthoMekf);
calculateAngleErrorTorque(sunDirB, sunDirRefB,
acsParameters->safeModeControllerParameters.k_alignMekf, inertiaMatrix);
2022-10-20 11:07:45 +02:00
2023-03-24 14:51:33 +01:00
// sum of all torques
for (uint8_t i = 0; i < 3; i++) {
cmdTorque[i] = cmdAlign[i] + cmdOrtho[i] + cmdParallel[i];
}
2022-10-20 11:07:45 +02:00
2023-04-05 16:11:28 +02:00
calculateMagneticMoment(magMomB);
2022-09-20 13:46:42 +02:00
}
2023-03-24 14:51:33 +01:00
void SafeCtrl::safeNonMekf(const double *magFieldB, const double *satRotRateB,
const double *sunDirB, const double *sunDirRefB,
2023-04-05 16:46:57 +02:00
const double satRotRateRef, const double inertiaMatrix[3][3],
2023-04-05 16:11:28 +02:00
double *magMomB, double &errorAngle) {
2023-03-24 11:35:46 +01:00
// convert magFieldB from uT to T
2023-03-22 08:59:29 +01:00
double magFieldBT[3] = {0, 0, 0};
VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
2023-03-21 17:19:27 +01:00
2023-04-05 16:11:28 +02:00
// calculate error angle between sunDirRef and sunDir
2023-03-24 11:35:46 +01:00
double dotSun = VectorOperations<double>::dot(sunDirRefB, sunDirB);
errorAngle = acos(dotSun);
2023-04-05 16:11:28 +02:00
splitRotationalRate(satRotRateB, sunDirB);
2023-04-05 16:46:57 +02:00
calculateRotationalRateTorque(satRotRateRef, sunDirB, sunDirRefB, errorAngle,
2023-04-05 16:11:28 +02:00
acsParameters->safeModeControllerParameters.k_parallelNonMekf,
acsParameters->safeModeControllerParameters.k_orthoNonMekf);
calculateAngleErrorTorque(sunDirB, sunDirRefB,
acsParameters->safeModeControllerParameters.k_alignNonMekf,
inertiaMatrix);
// sum of all torques
for (uint8_t i = 0; i < 3; i++) {
cmdTorque[i] = cmdAlign[i] + cmdOrtho[i] + cmdParallel[i];
}
calculateMagneticMoment(magMomB);
}
void SafeCtrl::safeRateDamping(const double *magFieldB, const double *satRotRateB,
2023-04-05 16:46:57 +02:00
const double satRotRateRef, const double *sunDirRefB,
2023-04-05 16:11:28 +02:00
double *magMomB, double &errorAngle) {
// convert magFieldB from uT to T
VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
// no error angle available for eclipse
errorAngle = NAN;
splitRotationalRate(satRotRateB, sunDirRefB);
2023-04-05 16:46:57 +02:00
calculateRotationalRateTorque(satRotRateRef, sunDirRefB, sunDirRefB, errorAngle,
2023-04-05 16:11:28 +02:00
acsParameters->safeModeControllerParameters.k_parallelNonMekf,
acsParameters->safeModeControllerParameters.k_orthoNonMekf);
// sum of all torques
double cmdTorque[3] = {0, 0, 0};
VectorOperations<double>::add(cmdParallel, cmdOrtho, cmdTorque, 3);
// calculate magnetic moment to command
calculateMagneticMoment(magMomB);
}
void SafeCtrl::splitRotationalRate(const double *satRotRateB, const double *sunDirB) {
2023-03-24 11:35:46 +01:00
// split rotational rate into parallel and orthogonal parts
double parallelLength = VectorOperations<double>::dot(satRotRateB, sunDirB) *
pow(VectorOperations<double>::norm(sunDirB, 3), -2);
VectorOperations<double>::mulScalar(sunDirB, parallelLength, satRotRateParallelB, 3);
VectorOperations<double>::subtract(satRotRateB, satRotRateParallelB, satRotRateOrthogonalB, 3);
2023-04-05 16:11:28 +02:00
}
2023-03-24 11:35:46 +01:00
2023-04-05 16:46:57 +02:00
void SafeCtrl::calculateRotationalRateTorque(const double satRotRateRef, const double *sunDirB,
2023-04-05 16:11:28 +02:00
const double *sunDirRefB, double &errorAngle,
const double gainParallel, const double gainOrtho) {
2023-03-24 11:35:46 +01:00
// calculate torque for parallel rotational rate
2023-04-05 16:11:28 +02:00
if ((isfinite(errorAngle)) and
(errorAngle < (double)acsParameters->safeModeControllerParameters.angleStartSpin)) {
2023-04-05 16:46:57 +02:00
double satRotRateNorm = VectorOperations<double>::norm(satRotRateParallelB, 3);
double satRotRateUnitVec[3] = {0, 0, 0};
VectorOperations<double>::normalize(satRotRateParallelB, satRotRateUnitVec, 3);
VectorOperations<double>::mulScalar(satRotRateUnitVec, satRotRateRef - satRotRateNorm,
cmdParallel, 3);
2023-04-05 16:11:28 +02:00
} else {
VectorOperations<double>::mulScalar(cmdParallel, -gainParallel, cmdParallel, 3);
2022-10-20 11:07:45 +02:00
}
2023-03-24 11:35:46 +01:00
// calculate torque for orthogonal rotational rate
2023-04-05 16:11:28 +02:00
VectorOperations<double>::mulScalar(satRotRateOrthogonalB, -gainOrtho, cmdOrtho, 3);
if (cos(VectorOperations<double>::dot(sunDirB, sunDirRefB)) < 0) {
VectorOperations<double>::mulScalar(cmdOrtho, -1, cmdOrtho, 3);
}
}
2023-03-24 11:35:46 +01:00
2023-04-05 16:11:28 +02:00
void SafeCtrl::calculateAngleErrorTorque(const double *sunDirB, const double *sunDirRefB,
const double gainAlign, const double inertiaMatrix[3][3]) {
2023-03-24 11:35:46 +01:00
// calculate torque for alignment
2023-04-05 16:11:28 +02:00
double crossAlign[3] = {0, 0, 0}, alignFactor[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
MatrixOperations<double>::multiplyScalar(*inertiaMatrix, gainAlign, *alignFactor, 3, 3);
2023-03-24 11:35:46 +01:00
VectorOperations<double>::cross(sunDirRefB, sunDirB, crossAlign);
2023-03-24 14:51:33 +01:00
MatrixOperations<double>::multiply(*alignFactor, crossAlign, cmdAlign, 3, 3, 1);
2023-03-21 17:19:27 +01:00
}
2023-03-24 14:51:33 +01:00
2023-04-05 16:11:28 +02:00
void SafeCtrl::calculateMagneticMoment(double *magMomB) {
2023-03-24 14:51:33 +01:00
double torqueMgt[3] = {0, 0, 0};
VectorOperations<double>::cross(magFieldBT, cmdTorque, torqueMgt);
2023-04-05 16:11:28 +02:00
double normMag = VectorOperations<double>::norm(magFieldBT, 3);
2023-03-24 14:51:33 +01:00
VectorOperations<double>::mulScalar(torqueMgt, pow(normMag, -2), magMomB, 3);
}