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

#include "ActuatorCmd.h"

#include <fsfw/globalfunctions/constants.h>
#include <fsfw/globalfunctions/math/MatrixOperations.h>
#include <fsfw/globalfunctions/math/QuaternionOperations.h>
#include <fsfw/globalfunctions/math/VectorOperations.h>

#include <cmath>

#include "util/CholeskyDecomposition.h"
#include "util/MathOperations.h"

ActuatorCmd::ActuatorCmd() {}

ActuatorCmd::~ActuatorCmd() {}

void ActuatorCmd::scalingTorqueRws(const double *rwTrq, double *rwTrqScaled,
                                   AcsParameters::RwHandlingParameters *rwHandlingParameters) {
  // Scaling the commanded torque to a maximum value
  double maxTrq = rwHandlingParameters->maxTrq;

  double maxValue = 0;
  for (int i = 0; i < 4; i++) {  // size of torque, always 4 ?
    if (abs(rwTrq[i]) > maxValue) {
      maxValue = abs(rwTrq[i]);
    }
  }

  if (maxValue > maxTrq) {
    double scalingFactor = maxTrq / maxValue;
    VectorOperations<double>::mulScalar(rwTrq, scalingFactor, rwTrqScaled, 4);
  }
}

void ActuatorCmd::cmdSpeedToRws(const int32_t speedRw0, const int32_t speedRw1,
                                const int32_t speedRw2, const int32_t speedRw3,
                                const double *rwTorque, int32_t *rwCmdSpeed,
                                AcsParameters *acsParameters) {
  using namespace Math;

  // Calculating the commanded speed in RPM for every reaction wheel
  int32_t speedRws[4] = {speedRw0, speedRw1, speedRw2, speedRw3};
  double deltaSpeed[4] = {0, 0, 0, 0};
  double radToRpm = 60 / (2 * PI);  // factor for conversion to RPM
  //	 W_RW = Torque_RW / I_RW * delta t [rad/s]
  double factor = acsParameters->onBoardParams.sampleTime /
                  acsParameters->rwHandlingParameters.inertiaWheel * radToRpm;
  int32_t deltaSpeedInt[4] = {0, 0, 0, 0};
  VectorOperations<double>::mulScalar(rwTorque, factor, deltaSpeed, 4);
  for (int i = 0; i < 4; i++) {
    deltaSpeedInt[i] = std::round(deltaSpeed[i]);
  }
  VectorOperations<int32_t>::add(speedRws, deltaSpeedInt, rwCmdSpeed, 4);
  VectorOperations<int32_t>::mulScalar(rwCmdSpeed, 10, rwCmdSpeed, 4);
}

void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, int16_t *dipolMomentActuator,
                              AcsParameters::MagnetorquerParameter *magnetorquerParameter) {
  // Convert to actuator frame
  double dipolMomentActuatorDouble[3] = {0, 0, 0};
  MatrixOperations<double>::multiply(*magnetorquerParameter->inverseAlignment, dipolMoment,
                                     dipolMomentActuatorDouble, 3, 3, 1);
  // Scaling along largest element if dipol exceeds maximum
  double maxDipol = magnetorquerParameter->dipolMax;
  double maxValue = 0;
  for (int i = 0; i < 3; i++) {
    if (abs(dipolMomentActuator[i]) > maxDipol) {
      maxValue = abs(dipolMomentActuator[i]);
    }
  }
  if (maxValue > maxDipol) {
    double scalingFactor = maxDipol / maxValue;
    VectorOperations<double>::mulScalar(dipolMomentActuatorDouble, scalingFactor,
                                        dipolMomentActuatorDouble, 3);
  }
  // scale dipole from 1 Am^2 to 1e^-4 Am^2
  VectorOperations<double>::mulScalar(dipolMomentActuatorDouble, 1e4, dipolMomentActuatorDouble, 3);
  for (int i = 0; i < 3; i++) {
    dipolMomentActuator[i] = std::round(dipolMomentActuatorDouble[i]);
  }
}