applyed CppStyle Format

2023-01-23 16:34:52 +01:00 · 2023-01-23 16:34:52 +01:00 · adef468c0b
commit adef468c0b
parent 44b384cd17
6 changed files with 714 additions and 683 deletions
--- a/mission/controller/AcsController.cpp
+++ b/mission/controller/AcsController.cpp
@ -26,7 +26,7 @@ AcsController::AcsController(object_id_t objectId)
      ctrlValData(this),
      actuatorCmdData(this) {}

-ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
+ReturnValue_t AcsController::handleCommandMessage(CommandMessage* message) {
  ReturnValue_t result = actionHelper.handleActionMessage(message);
  if (result == returnvalue::OK) {
    return result;
@ -103,9 +103,9 @@ void AcsController::performControlOperation() {
      copyGyrData();
    }
  }
-  }
+}

-  void AcsController::performSafe() {
+void AcsController::performSafe() {
  ACS::SensorValues sensorValues;

  timeval now;
@ -125,19 +125,17 @@ void AcsController::performControlOperation() {
  bool magMomMtqValid = false;
  if (validMekf == returnvalue::OK) {
    safeCtrl.safeMekf(now, mekfData.quatMekf.value, mekfData.quatMekf.isValid(),
-                        mgmDataProcessed.magIgrfModel.value,
-                        mgmDataProcessed.magIgrfModel.isValid(), susDataProcessed.sunIjkModel.value,
-                        susDataProcessed.isValid(), mekfData.satRotRateMekf.value,
-                        mekfData.satRotRateMekf.isValid(), sunTargetDir, satRateSafe, &errAng,
-                        magMomMtq, &magMomMtqValid);
+                      mgmDataProcessed.magIgrfModel.value, mgmDataProcessed.magIgrfModel.isValid(),
+                      susDataProcessed.sunIjkModel.value, susDataProcessed.isValid(),
+                      mekfData.satRotRateMekf.value, mekfData.satRotRateMekf.isValid(),
+                      sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
  } else {
    safeCtrl.safeNoMekf(
        now, susDataProcessed.susVecTot.value, susDataProcessed.susVecTot.isValid(),
-          susDataProcessed.susVecTotDerivative.value,
-          susDataProcessed.susVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), mgmDataProcessed.mgmVecTotDerivative.value,
-          mgmDataProcessed.mgmVecTotDerivative.isValid(), sunTargetDir, satRateSafe, &errAng,
-          magMomMtq, &magMomMtqValid);
+        susDataProcessed.susVecTotDerivative.value, susDataProcessed.susVecTotDerivative.isValid(),
+        mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+        mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTotDerivative.isValid(),
+        sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
  }

  double dipolCmdUnits[3] = {0, 0, 0};
@ -194,9 +192,9 @@ void AcsController::performControlOperation() {
  //    dipoleSet.setDipoles(cmdDipolUnits[0], cmdDipolUnits[1], cmdDipolUnits[2],
  //    torqueDuration);
  //  }
-  }
+}

-  void AcsController::performDetumble() {
+void AcsController::performDetumble() {
  ACS::SensorValues sensorValues;

  timeval now;
@ -209,9 +207,9 @@ void AcsController::performControlOperation() {
                     &mekfData, &validMekf);

  double magMomMtq[3] = {0, 0, 0};
-    detumble.bDotLaw(
-        mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTotDerivative.isValid(),
-        mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
+  detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value,
+                   mgmDataProcessed.mgmVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
+                   mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
  double dipolCmdUnits[3] = {0, 0, 0};
  actuatorCmd.cmdDipolMtq(magMomMtq, dipolCmdUnits);

@ -254,9 +252,9 @@ void AcsController::performControlOperation() {
  //	  dipoleSet.setDipoles(cmdDipolUnitsInt[0], cmdDipolUnitsInt[1], cmdDipolUnitsInt[2],
  // torqueDuration);
  //  }
-  }
+}

-  void AcsController::performPointingCtrl() {
+void AcsController::performPointingCtrl() {
  ACS::SensorValues sensorValues;

  timeval now;
@ -284,16 +282,21 @@ void AcsController::performControlOperation() {
    case SUBMODE_IDLE:
      guidance.sunQuatPtg(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
                          targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
      VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
      actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
          mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@ -301,36 +304,46 @@ void AcsController::performControlOperation() {
      break;

    case SUBMODE_PTG_TARGET:
-        guidance.targetQuatPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now,
-                                        targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      guidance.targetQuatPtgThreeAxes(&sensorValues, &gpsDataProcessed, &mekfData, now, targetQuat,
+                                      refSatRate);
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
      VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
      actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
          mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
      break;

    case SUBMODE_PTG_TARGET_GS:
-        guidance.targetQuatPtgGs(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed,
-                                 now, targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef, 4 * sizeof(double));
+      guidance.targetQuatPtgGs(&sensorValues, &mekfData, &susDataProcessed, &gpsDataProcessed, now,
+                               targetQuat, refSatRate);
+      std::memcpy(quatRef, acsParameters.targetModeControllerParameters.quatRef,
+                  4 * sizeof(double));
      enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
-                    &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-                    &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
      VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
      actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
          mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@ -341,14 +354,18 @@ void AcsController::performControlOperation() {
                                     refSatRate);
      std::memcpy(quatRef, acsParameters.nadirModeControllerParameters.quatRef, 4 * sizeof(double));
      enableAntiStiction = acsParameters.nadirModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.nadirModeControllerParameters,
-            &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-            &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.nadirModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
      VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
      actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
          mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
@ -356,23 +373,28 @@ void AcsController::performControlOperation() {

    case SUBMODE_PTG_INERTIAL:
      guidance.inertialQuatPtg(targetQuat, refSatRate);
-        std::memcpy(quatRef, acsParameters.inertialModeControllerParameters.quatRef, 4 * sizeof(double));
+      std::memcpy(quatRef, acsParameters.inertialModeControllerParameters.quatRef,
+                  4 * sizeof(double));
      enableAntiStiction = acsParameters.inertialModeControllerParameters.enableAntiStiction;
-        guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError, deltaRate);
-        ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, quatError, deltaRate, *rwPseudoInv, torquePtgRws);
-        ptgCtrl.ptgNullspace(&acsParameters.inertialModeControllerParameters,
-            &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-            &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      guidance.comparePtg(targetQuat, &mekfData, quatRef, refSatRate, quatErrorComplete, quatError,
+                          deltaRate);
+      ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, quatError, deltaRate,
+                     *rwPseudoInv, torquePtgRws);
+      ptgCtrl.ptgNullspace(
+          &acsParameters.inertialModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
+          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
+          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
      VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
      actuatorCmd.scalingTorqueRws(torqueRws, torqueRwsScaled);
-        ptgCtrl.ptgDesaturation(&acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
+      ptgCtrl.ptgDesaturation(
+          &acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
          mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
      break;
  }

-    if ( enableAntiStiction ) {
+  if (enableAntiStiction) {
    bool rwAvailable[4] = {true, true, true, true};  // WHICH INPUT SENSOR SET?
    int32_t rwSpeed[4] = {
        (sensorValues.rw1Set.currSpeed.value), (sensorValues.rw2Set.currSpeed.value),
@ -380,8 +402,7 @@ void AcsController::performControlOperation() {
    ptgCtrl.rwAntistiction(rwAvailable, rwSpeed, torqueRwsScaled);
  }

-    double cmdSpeedRws[4] = {0, 0, 0,
-                             0};  // Should be given to the actuator reaction wheel as input
+  double cmdSpeedRws[4] = {0, 0, 0, 0};  // Should be given to the actuator reaction wheel as input
  actuatorCmd.cmdSpeedToRws(&(sensorValues.rw1Set.currSpeed.value),
                            &(sensorValues.rw2Set.currSpeed.value),
                            &(sensorValues.rw3Set.currSpeed.value),
@ -413,10 +434,10 @@ void AcsController::performControlOperation() {
  //	  dipoleSet.setDipoles(cmdDipolUnitsInt[0], cmdDipolUnitsInt[1], cmdDipolUnitsInt[2],
  // torqueDuration);
  //  }
-  }
+}

-  ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool & localDataPoolMap,
-                                                       LocalDataPoolManager & poolManager) {
+ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                     LocalDataPoolManager& poolManager) {
  // MGM Raw
  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_0_LIS3_UT, &mgm0VecRaw);
  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_1_RM3100_UT, &mgm1VecRaw);
@ -500,9 +521,9 @@ void AcsController::performControlOperation() {
  localDataPoolMap.emplace(acsctrl::PoolIds::MTQ_TARGET_DIPOLE, &mtqTargetDipole);
  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), false, 5.0});
  return returnvalue::OK;
-  }
+}

-  LocalPoolDataSetBase *AcsController::getDataSetHandle(sid_t sid) {
+LocalPoolDataSetBase* AcsController::getDataSetHandle(sid_t sid) {
  switch (sid.ownerSetId) {
    case acsctrl::MGM_SENSOR_DATA:
      return &mgmDataRaw;
@ -528,10 +549,10 @@ void AcsController::performControlOperation() {
      return nullptr;
  }
  return nullptr;
-  }
+}

-  ReturnValue_t AcsController::checkModeCommand(Mode_t mode, Submode_t submode,
-                                                uint32_t * msToReachTheMode) {
+ReturnValue_t AcsController::checkModeCommand(Mode_t mode, Submode_t submode,
+                                              uint32_t* msToReachTheMode) {
  if (mode == MODE_OFF) {
    if (submode == SUBMODE_NONE) {
      return returnvalue::OK;
@ -546,9 +567,9 @@ void AcsController::performControlOperation() {
    }
  }
  return INVALID_MODE;
-  }
+}

-  void AcsController::copyMgmData() {
+void AcsController::copyMgmData() {
  ACS::SensorValues sensorValues;
  {
    PoolReadGuard pg(&sensorValues.mgm0Lis3Set);
@ -589,13 +610,12 @@ void AcsController::performControlOperation() {
                  3 * sizeof(float));
      mgmDataRaw.imtqRaw.setValid(sensorValues.imtqMgmSet.mtmRawNt.isValid());
      mgmDataRaw.actuationCalStatus.value = sensorValues.imtqMgmSet.coilActuationStatus.value;
-        mgmDataRaw.actuationCalStatus.setValid(
-            sensorValues.imtqMgmSet.coilActuationStatus.isValid());
-      }
+      mgmDataRaw.actuationCalStatus.setValid(sensorValues.imtqMgmSet.coilActuationStatus.isValid());
    }
  }
+}

-  void AcsController::copySusData() {
+void AcsController::copySusData() {
  ACS::SensorValues sensorValues;
  {
    PoolReadGuard pg(&sensorValues.susSets[0]);
@ -693,9 +713,9 @@ void AcsController::performControlOperation() {
      susDataRaw.sus11.setValid(sensorValues.susSets[11].channels.isValid());
    }
  }
-  }
+}

-  void AcsController::copyGyrData() {
+void AcsController::copyGyrData() {
  ACS::SensorValues sensorValues;
  {
    PoolReadGuard pg(&sensorValues.gyr0AdisSet);
@ -741,4 +761,4 @@ void AcsController::performControlOperation() {
                                 sensorValues.gyr3L3gSet.angVelocZ.isValid());
    }
  }
-  }
+}
--- a/mission/controller/acs/AcsParameters.h
+++ b/mission/controller/acs/AcsParameters.h
@ -816,7 +816,6 @@ class AcsParameters : public HasParametersIF {
  } safeModeControllerParameters;

  struct PointingLawParameters {
-
    double zeta = 0.3;
    double om = 0.3;
    double omMax = 1 * M_PI / 180;
--- a/mission/controller/acs/Guidance.cpp
+++ b/mission/controller/acs/Guidance.cpp
@ -42,7 +42,8 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
  double targetCart[3] = {0, 0, 0};

  MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
      acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);

  //	Position of the satellite in the earth/fixed frame via GPS
@ -172,12 +173,12 @@ void Guidance::targetQuatPtgSingleAxis(ACS::SensorValues *sensorValues, acsctrl:
  }
 }

-void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4], double *refSatRate) {
+void Guidance::refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                               double *refSatRate) {
  //-------------------------------------------------------------------------------------
  //	Calculation of reference rotation rate
  //-------------------------------------------------------------------------------------
-  double timeElapsed =
-      now.tv_sec + now.tv_usec * pow(10, -6) -
+  double timeElapsed = now.tv_sec + now.tv_usec * pow(10, -6) -
                       (timeSavedQuaternion.tv_sec +
                        timeSavedQuaternion.tv_usec * pow((double)timeSavedQuaternion.tv_usec, -6));
  if (timeElapsed < timeElapsedMax) {
@ -226,7 +227,8 @@ void Guidance::targetQuatPtgThreeAxes(ACS::SensorValues *sensorValues,
  double targetCart[3] = {0, 0, 0};

  MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
      acsParameters.targetModeControllerParameters.altitudeTgt, targetCart);
  //	Position of the satellite in the earth/fixed frame via GPS
  double posSatE[3] = {0, 0, 0};
@ -307,7 +309,8 @@ void Guidance::targetQuatPtgGs(ACS::SensorValues *sensorValues, acsctrl::MekfDat
  double groundStationCart[3] = {0, 0, 0};

  MathOperations<double>::cartesianFromLatLongAlt(
-      acsParameters.targetModeControllerParameters.latitudeTgt, acsParameters.targetModeControllerParameters.longitudeTgt,
+      acsParameters.targetModeControllerParameters.latitudeTgt,
+      acsParameters.targetModeControllerParameters.longitudeTgt,
      acsParameters.targetModeControllerParameters.altitudeTgt, groundStationCart);
  //	Position of the satellite in the earth/fixed frame via GPS
  double posSatE[3] = {0, 0, 0};
@ -588,13 +591,15 @@ void Guidance::quatNadirPtgThreeAxes(ACS::SensorValues *sensorValues,
 }

 void Guidance::inertialQuatPtg(double targetQuat[4], double refSatRate[3]) {
-  std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat, 4 * sizeof(double));
-  std::memcpy(refSatRate, acsParameters.inertialModeControllerParameters.refRotRate, 3 * sizeof(double));
+  std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat,
+              4 * sizeof(double));
+  std::memcpy(refSatRate, acsParameters.inertialModeControllerParameters.refRotRate,
+              3 * sizeof(double));
 }

-void Guidance::comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4], double refSatRate[3],
-                          double quatErrorComplete[4], double quatError[3], double deltaRate[3]) {
-
+void Guidance::comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
+                          double refSatRate[3], double quatErrorComplete[4], double quatError[3],
+                          double deltaRate[3]) {
  double satRate[3] = {0, 0, 0};
  std::memcpy(satRate, mekfData->satRotRateMekf.value, 3 * sizeof(double));
  VectorOperations<double>::subtract(satRate, refSatRate, deltaRate, 3);
--- a/mission/controller/acs/Guidance.h
+++ b/mission/controller/acs/Guidance.h
@ -58,10 +58,12 @@ class Guidance {

  // @note: compares target Quaternion and reference quaternion, also actual satellite rate and
  // desired
-  void comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4], double refSatRate[3],
-                  double quatErrorComplete[4], double quatError[3], double deltaRate[3]);
+  void comparePtg(double targetQuat[4], acsctrl::MekfData *mekfData, double quatRef[4],
+                  double refSatRate[3], double quatErrorComplete[4], double quatError[3],
+                  double deltaRate[3]);

-  void refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4], double *refSatRate);
+  void refRotationRate(int8_t timeElapsedMax, timeval now, double quatInertialTarget[4],
+                       double *refSatRate);

  //	@note: will give back the pseudoinverse matrix for the reaction wheel depending on the valid
  // reation wheel 	maybe can be done in "commanding.h"
--- a/mission/controller/acs/control/PtgCtrl.cpp
+++ b/mission/controller/acs/control/PtgCtrl.cpp
@ -26,8 +26,9 @@ void PtgCtrl::loadAcsParameters(AcsParameters *acsParameters_) {
  rwMatrices = &(acsParameters_->rwMatrices);
 }

-void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameters, const double *qError, const double *deltaRate,
-                     const double *rwPseudoInv, double *torqueRws) {
+void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters *pointingLawParameters,
+                     const double *qError, const double *deltaRate, const double *rwPseudoInv,
+                     double *torqueRws) {
  //------------------------------------------------------------------------------------------------
  // Compute gain matrix K and P matrix
  //------------------------------------------------------------------------------------------------
@ -106,7 +107,8 @@ void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameter
  VectorOperations<double>::mulScalar(torqueRws, -1, torqueRws, 4);
 }

-void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLawParameters, double *magFieldEst, bool magFieldEstValid, double *satRate,
+void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
+                              double *magFieldEst, bool magFieldEstValid, double *satRate,
                              int32_t *speedRw0, int32_t *speedRw1, int32_t *speedRw2,
                              int32_t *speedRw3, double *mgtDpDes) {
  if (!(magFieldEstValid) || !(pointingLawParameters->desatOn)) {
@ -127,8 +129,8 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLaw
  VectorOperations<double>::add(momentumSat, momentumRw, momentumTotal, 3);
  //	calculating momentum error
  double deltaMomentum[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(
-      momentumTotal, pointingLawParameters->desatMomentumRef, deltaMomentum, 3);
+  VectorOperations<double>::subtract(momentumTotal, pointingLawParameters->desatMomentumRef,
+                                     deltaMomentum, 3);
  //	resulting magnetic dipole command
  double crossMomentumMagField[3] = {0, 0, 0};
  VectorOperations<double>::cross(deltaMomentum, magFieldEst, crossMomentumMagField);
@ -137,7 +139,8 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters * pointingLaw
  VectorOperations<double>::mulScalar(crossMomentumMagField, factor, mgtDpDes, 3);
 }

-void PtgCtrl::ptgNullspace(AcsParameters::PointingLawParameters * pointingLawParameters, const int32_t *speedRw0, const int32_t *speedRw1,
+void PtgCtrl::ptgNullspace(AcsParameters::PointingLawParameters *pointingLawParameters,
+                           const int32_t *speedRw0, const int32_t *speedRw1,
                           const int32_t *speedRw2, const int32_t *speedRw3, double *rwTrqNs) {
  double speedRws[4] = {(double)*speedRw0, (double)*speedRw1, (double)*speedRw2, (double)*speedRw3};
  double wheelMomentum[4] = {0, 0, 0, 0};
--- a/mission/controller/acs/control/PtgCtrl.h
+++ b/mission/controller/acs/control/PtgCtrl.h
@ -41,14 +41,16 @@ class PtgCtrl {
  /* @brief: Calculates the needed torque for the pointing control mechanism
   * @param: acsParameters_ Pointer to object which defines the ACS configuration parameters
   */
-  void ptgLaw(AcsParameters::PointingLawParameters * pointingLawParameters, const double *qError, const double *deltaRate,
-              const double *rwPseudoInv, double *torqueRws);
+  void ptgLaw(AcsParameters::PointingLawParameters *pointingLawParameters, const double *qError,
+              const double *deltaRate, const double *rwPseudoInv, double *torqueRws);

-  void ptgDesaturation(AcsParameters::PointingLawParameters * pointingLawParameters, double *magFieldEst,
-		  	  	  	   bool magFieldEstValid, double *satRate, int32_t *speedRw0, int32_t *speedRw1,
-					   int32_t *speedRw2, int32_t *speedRw3, double *mgtDpDes);
+  void ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
+                       double *magFieldEst, bool magFieldEstValid, double *satRate,
+                       int32_t *speedRw0, int32_t *speedRw1, int32_t *speedRw2, int32_t *speedRw3,
+                       double *mgtDpDes);

-  void ptgNullspace(AcsParameters::PointingLawParameters * pointingLawParameters, const int32_t *speedRw0, const int32_t *speedRw1, const int32_t *speedRw2,
+  void ptgNullspace(AcsParameters::PointingLawParameters *pointingLawParameters,
+                    const int32_t *speedRw0, const int32_t *speedRw1, const int32_t *speedRw2,
                    const int32_t *speedRw3, double *rwTrqNs);

  /* @brief: Commands the stiction torque in case wheel speed is to low