changelog

Reviewed-on: #907

CHANGELOG.md

@@ -16,6 +16,37 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+## Changed
+
+- Readded rotation rate from the `MEKF` to the detumble state machine.
+
+# [v8.2.0] 2024-06-26
+
+## Changed
+
+- STR quaternions are now used by the `MEKF` by default
+- Changed nominal `SUS Assembly` side to `B Side`.
+- Changed source for state machine of detumbling to SUS and MGM only.
+- Changed `FusedRotRateData` dataset to always display rotation rate from SUS and MGM.
+- Solution from `QUEST` will be set to invalid if sun vector and magnetic field vector are too close
+  to each other.
+- Changed collection intervals of dataset collection
+  - `GPS Controller`: `GPS Set` to 60s
+  - `MTQ Handler`: `HK with Torque`, `HK without Torque` to 60s
+  - `RW Handler`: `Status Set` to 30s
+  - `STR Handler`: `Solution Set` to 30s
+  - `ACS Controller`: `MGM Sensor`, `MGM Processed`, `SUS Sensor`, `SUS Processed`, `GYR Sensor`,
+    `GPS Processed` to 60s
+  - `ACS Controller` at or below `IDLE`: `CTRL Values`, `ACT Commands`, `Attitude Estimation`,
+    `Fused Rotation Rate` to 30s
+  - `ACS Controller` above `IDLE`: `CTRL Values`, `ACT Commands`, `Attitude Estimation`,
+    `Fused Rotation Rate` to 10s
+
+## Fixed
+
+- Added null termination for PLOC MPSoC image taking command which could possibly lead to
+  default target filenames.
+
 # [v8.1.1] 2024-06-05
 
 ## Added

CMakeLists.txt

@@ -10,8 +10,8 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 8)
-set(OBSW_VERSION_MINOR 1)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_MINOR 2)
+set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
 

linux/acs/GpsHyperionLinuxController.cpp

@@ -100,7 +100,7 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
-  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 60.0});
   localDataPoolMap.emplace(GpsHyperion::SKYVIEW_UNIX_SECONDS, new PoolEntry<double>());
   localDataPoolMap.emplace(GpsHyperion::PRN_ID, new PoolEntry<int16_t>());
   localDataPoolMap.emplace(GpsHyperion::AZIMUTH, new PoolEntry<int16_t>());

linux/payload/plocMpsocHelpers.h

@@ -920,13 +920,14 @@ class TcCamTakePic : public TcBase {
     }
     size_t deserLen = commandDataLen;
     size_t serLen = 0;
-    fileName = reinterpret_cast<const char*>(commandData);
+    fileName = std::string(reinterpret_cast<const char*>(commandData));
     if (fileName.size() > MAX_FILENAME_SIZE) {
       return FILENAME_TOO_LONG;
     }
     deserLen -= fileName.length() + 1;
     *dataPtr += fileName.length() + 1;
     uint8_t** payloadPtr = &payloadStart;
+    memset(payloadStart, 0, FILENAME_FIELD_SIZE);
     memcpy(payloadStart, fileName.data(), fileName.size());
     *payloadPtr += FILENAME_FIELD_SIZE;
     serLen += FILENAME_FIELD_SIZE;

mission/acs/ImtqHandler.cpp

@@ -795,9 +795,9 @@ ReturnValue_t ImtqHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(imtq::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 60.0));
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(

mission/acs/RwHandler.cpp

@@ -340,7 +340,7 @@ ReturnValue_t RwHandler::initializeLocalDataPool(localpool::DataPool& localDataP
   localDataPoolMap.emplace(rws::SPI_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(rws::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(tmDataset.getSid(), false, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(

mission/acs/str/StarTrackerHandler.cpp

@@ -1662,7 +1662,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(interfaceSet.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(solutionSet.getSid(), false, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(solutionSet.getSid(), false, 30.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(cameraSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(

mission/controller/AcsController.cpp

@@ -232,7 +232,8 @@ void AcsController::performSafe() {
   acs::ControlModeStrategy safeCtrlStrat = safeCtrl.safeCtrlStrategy(
       mgmDataProcessed.mgmVecTot.isValid(), not mekfInvalidFlag,
       gyrDataProcessed.gyrVecTot.isValid(), susDataProcessed.susVecTot.isValid(),
-      fusedRotRateData.rotRateTotal.isValid(), acsParameters.safeModeControllerParameters.useMekf,
+      fusedRotRateSourcesData.rotRateTotalSusMgm.isValid(),
+      acsParameters.safeModeControllerParameters.useMekf,
       acsParameters.safeModeControllerParameters.useGyr,
       acsParameters.safeModeControllerParameters.dampingDuringEclipse);
   switch (safeCtrlStrat) {
@@ -251,9 +252,10 @@ void AcsController::performSafe() {
       safeCtrlFailureCounter = 0;
       break;
     case (acs::ControlModeStrategy::SAFECTRL_SUSMGM):
-      safeCtrl.safeSusMgm(mgmDataProcessed.mgmVecTot.value, fusedRotRateData.rotRateTotal.value,
-                          fusedRotRateData.rotRateParallel.value,
-                          fusedRotRateData.rotRateOrthogonal.value,
+      safeCtrl.safeSusMgm(mgmDataProcessed.mgmVecTot.value,
+                          fusedRotRateSourcesData.rotRateTotalSusMgm.value,
+                          fusedRotRateSourcesData.rotRateParallelSusMgm.value,
+                          fusedRotRateSourcesData.rotRateOrthogonalSusMgm.value,
                           susDataProcessed.susVecTot.value, sunTargetDir, magMomMtq, errAng);
       safeCtrlFailureFlag = false;
       safeCtrlFailureCounter = 0;
@@ -267,8 +269,8 @@ void AcsController::performSafe() {
       break;
     case (acs::ControlModeStrategy::SAFECTRL_ECLIPSE_DAMPING_SUSMGM):
       safeCtrl.safeRateDampingSusMgm(mgmDataProcessed.mgmVecTot.value,
-                                     fusedRotRateData.rotRateTotal.value, sunTargetDir, magMomMtq,
-                                     errAng);
+                                     fusedRotRateSourcesData.rotRateTotalSusMgm.value, sunTargetDir,
+                                     magMomMtq, errAng);
       safeCtrlFailureFlag = false;
       safeCtrlFailureCounter = 0;
       break;
@@ -355,7 +357,7 @@ void AcsController::performPointingCtrl() {
   }
   acs::ControlModeStrategy ptgCtrlStrat = ptgCtrl.pointingCtrlStrategy(
       mgmDataProcessed.mgmVecTot.isValid(), not mekfInvalidFlag, strValid,
-      attitudeEstimationData.quatQuest.isValid(), fusedRotRateData.rotRateTotal.isValid(),
+      attitudeEstimationData.quatQuest.isValid(), fusedRotRateData.rotRateTotalSource.isValid(),
       fusedRotRateData.rotRateSource.value, useMekf);
 
   if (ptgCtrlStrat == acs::ControlModeStrategy::CTRL_NO_MAG_FIELD_FOR_CONTROL or
@@ -387,11 +389,11 @@ void AcsController::performPointingCtrl() {
       quatBI[1] = sensorValues.strSet.caliQy.value;
       quatBI[2] = sensorValues.strSet.caliQz.value;
       quatBI[3] = sensorValues.strSet.caliQw.value;
-      std::memcpy(rotRateB, fusedRotRateData.rotRateTotal.value, sizeof(rotRateB));
+      std::memcpy(rotRateB, fusedRotRateData.rotRateTotalSource.value, sizeof(rotRateB));
       break;
     case acs::ControlModeStrategy::PTGCTRL_QUEST:
       std::memcpy(quatBI, attitudeEstimationData.quatQuest.value, sizeof(quatBI));
-      std::memcpy(rotRateB, fusedRotRateData.rotRateTotal.value, sizeof(rotRateB));
+      std::memcpy(rotRateB, fusedRotRateData.rotRateTotalSource.value, sizeof(rotRateB));
       break;
     default:
       sif::error << "AcsController: Invalid pointing mode strategy for performPointingCtrl"
@@ -555,9 +557,12 @@ void AcsController::performPointingCtrl() {
 void AcsController::handleDetumbling() {
   switch (detumbleState) {
     case DetumbleState::NO_DETUMBLE:
-      if (fusedRotRateData.rotRateTotal.isValid() and
-          VectorOperations<double>::norm(fusedRotRateData.rotRateTotal.value, 3) >
-              acsParameters.detumbleParameter.omegaDetumbleStart) {
+      if ((fusedRotRateData.rotRateTotalSusMgm.isValid() and
+           VectorOperations<double>::norm(fusedRotRateData.rotRateTotalSusMgm.value, 3) >
+               acsParameters.detumbleParameter.omegaDetumbleStart) and
+          (attitudeEstimationData.satRotRateMekf.isValid() and
+           VectorOperations<double>::norm(attitudeEstimationData.satRotRateMekf.value, 3) >
+               acsParameters.detumbleParameter.omegaDetumbleStart)) {
         detumbleCounter++;
       } else if (detumbleCounter > 0) {
         detumbleCounter -= 1;
@@ -599,9 +604,12 @@ void AcsController::handleDetumbling() {
       detumbleState = DetumbleState::NO_DETUMBLE;
       break;
     case DetumbleState::IN_DETUMBLE:
-      if (fusedRotRateData.rotRateTotal.isValid() and
-          VectorOperations<double>::norm(fusedRotRateData.rotRateTotal.value, 3) <
-              acsParameters.detumbleParameter.omegaDetumbleEnd) {
+      if ((fusedRotRateData.rotRateTotalSusMgm.isValid() and
+           VectorOperations<double>::norm(fusedRotRateData.rotRateTotalSusMgm.value, 3) <
+               acsParameters.detumbleParameter.omegaDetumbleEnd) and
+          (attitudeEstimationData.satRotRateMekf.isValid() and
+           VectorOperations<double>::norm(attitudeEstimationData.satRotRateMekf.value, 3) <
+               acsParameters.detumbleParameter.omegaDetumbleEnd)) {
         detumbleCounter++;
       } else if (detumbleCounter > 0) {
         detumbleCounter -= 1;
@@ -747,7 +755,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_3_RM3100_UT, &mgm3VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_NT, &imtqMgmVecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_ACT_STATUS, &imtqCalActStatus);
-  poolManager.subscribeForRegularPeriodicPacket({mgmDataRaw.getSid(), false, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({mgmDataRaw.getSid(), false, 60.0});
   // MGM Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_0_VEC, &mgm0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_1_VEC, &mgm1VecProc);
@@ -757,7 +765,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_VEC_TOT, &mgmVecTot);
   localDataPoolMap.emplace(acsctrl::PoolIds::MGM_VEC_TOT_DERIVATIVE, &mgmVecTotDer);
   localDataPoolMap.emplace(acsctrl::PoolIds::MAG_IGRF_MODEL, &magIgrf);
-  poolManager.subscribeForRegularPeriodicPacket({mgmDataProcessed.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({mgmDataProcessed.getSid(), enableHkSets, 60.0});
   // SUS Raw
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_0_N_LOC_XFYFZM_PT_XF, &sus0ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_1_N_LOC_XBYFZM_PT_XB, &sus1ValRaw);
@@ -771,7 +779,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_9_R_LOC_XBYBZB_PT_YF, &sus9ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_10_N_LOC_XMYBZF_PT_ZF, &sus10ValRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_11_R_LOC_XBYMZB_PT_ZB, &sus11ValRaw);
-  poolManager.subscribeForRegularPeriodicPacket({susDataRaw.getSid(), false, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({susDataRaw.getSid(), false, 60.0});
   // SUS Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_0_VEC, &sus0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_1_VEC, &sus1VecProc);
@@ -788,20 +796,20 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_VEC_TOT, &susVecTot);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUS_VEC_TOT_DERIVATIVE, &susVecTotDer);
   localDataPoolMap.emplace(acsctrl::PoolIds::SUN_IJK_MODEL, &sunIjk);
-  poolManager.subscribeForRegularPeriodicPacket({susDataProcessed.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({susDataProcessed.getSid(), enableHkSets, 60.0});
   // GYR Raw
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_ADIS, &gyr0VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_L3, &gyr1VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_ADIS, &gyr2VecRaw);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_L3, &gyr3VecRaw);
-  poolManager.subscribeForDiagPeriodicPacket({gyrDataRaw.getSid(), false, 10.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataRaw.getSid(), false, 60.0});
   // GYR Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_0_VEC, &gyr0VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_1_VEC, &gyr1VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_2_VEC, &gyr2VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_3_VEC, &gyr3VecProc);
   localDataPoolMap.emplace(acsctrl::PoolIds::GYR_VEC_TOT, &gyrVecTot);
-  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForDiagPeriodicPacket({gyrDataProcessed.getSid(), enableHkSets, 60.0});
   // GPS Processed
   localDataPoolMap.emplace(acsctrl::PoolIds::GC_LATITUDE, &gcLatitude);
   localDataPoolMap.emplace(acsctrl::PoolIds::GD_LONGITUDE, &gdLongitude);
@@ -809,38 +817,37 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::GPS_POSITION, &gpsPosition);
   localDataPoolMap.emplace(acsctrl::PoolIds::GPS_VELOCITY, &gpsVelocity);
   localDataPoolMap.emplace(acsctrl::PoolIds::SOURCE, &gpsSource);
-  poolManager.subscribeForRegularPeriodicPacket({gpsDataProcessed.getSid(), enableHkSets, 30.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsDataProcessed.getSid(), enableHkSets, 60.0});
   // Attitude Estimation
   localDataPoolMap.emplace(acsctrl::PoolIds::QUAT_MEKF, &quatMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::SAT_ROT_RATE_MEKF, &satRotRateMekf);
   localDataPoolMap.emplace(acsctrl::PoolIds::MEKF_STATUS, &mekfStatus);
   localDataPoolMap.emplace(acsctrl::PoolIds::QUAT_QUEST, &quatQuest);
-  poolManager.subscribeForDiagPeriodicPacket({attitudeEstimationData.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForDiagPeriodicPacket({attitudeEstimationData.getSid(), enableHkSets, 30.0});
   // Ctrl Values
   localDataPoolMap.emplace(acsctrl::PoolIds::SAFE_STRAT, &safeStrat);
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_QUAT, &tgtQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_QUAT, &errQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_ANG, &errAng);
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_ROT_RATE, &tgtRotRate);
-  poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({ctrlValData.getSid(), enableHkSets, 30.0});
   // Actuator CMD
   localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_TORQUE, &rwTargetTorque);
   localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_SPEED, &rwTargetSpeed);
   localDataPoolMap.emplace(acsctrl::PoolIds::MTQ_TARGET_DIPOLE, &mtqTargetDipole);
-  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 30.0});
   // Fused Rot Rate
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_ORTHOGONAL, &rotRateOrthogonal);
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_PARALLEL, &rotRateParallel);
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOTAL, &rotRateTotal);
+  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOT_SUSMGM, &rotRateTotSusMgm);
+  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOT_SOURCE, &rotRateTotSource);
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_SOURCE, &rotRateSource);
-  poolManager.subscribeForRegularPeriodicPacket({fusedRotRateData.getSid(), enableHkSets, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({fusedRotRateData.getSid(), enableHkSets, 30.0});
   // Fused Rot Rate Sources
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_ORTHOGONAL_SUSMGM, &rotRateOrthogonalSusMgm);
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_PARALLEL_SUSMGM, &rotRateParallelSusMgm);
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOTAL_SUSMGM, &rotRateTotalSusMgm);
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOTAL_QUEST, &rotRateTotalQuest);
   localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOTAL_STR, &rotRateTotalStr);
-  poolManager.subscribeForRegularPeriodicPacket({fusedRotRateSourcesData.getSid(), false, 10.0});
+  poolManager.subscribeForRegularPeriodicPacket({fusedRotRateSourcesData.getSid(), false, 60.0});
   return returnvalue::OK;
 }
 
@@ -926,6 +933,17 @@ void AcsController::modeChanged(Mode_t mode, Submode_t submode) {
   if (detumbleState == DetumbleState::IN_DETUMBLE and submode != acs::SafeSubmode::DETUMBLE) {
     detumbleState = DetumbleState::NO_DETUMBLE;
   }
+  if (mode > acs::AcsMode::PTG_IDLE) {
+    poolManager.changeCollectionInterval(ctrlValData.getSid(), 10);
+    poolManager.changeCollectionInterval(actuatorCmdData.getSid(), 10);
+    poolManager.changeCollectionInterval(fusedRotRateData.getSid(), 10);
+    poolManager.changeCollectionInterval(attitudeEstimationData.getSid(), 10);
+  } else {
+    poolManager.changeCollectionInterval(ctrlValData.getSid(), 30);
+    poolManager.changeCollectionInterval(actuatorCmdData.getSid(), 30);
+    poolManager.changeCollectionInterval(fusedRotRateData.getSid(), 30);
+    poolManager.changeCollectionInterval(attitudeEstimationData.getSid(), 30);
+  }
   return ExtendedControllerBase::modeChanged(mode, submode);
 }
 

mission/controller/AcsController.h

@@ -271,9 +271,8 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
 
   // Fused Rot Rate
   acsctrl::FusedRotRateData fusedRotRateData;
-  PoolEntry<double> rotRateOrthogonal = PoolEntry<double>(3);
-  PoolEntry<double> rotRateParallel = PoolEntry<double>(3);
-  PoolEntry<double> rotRateTotal = PoolEntry<double>(3);
+  PoolEntry<double> rotRateTotSusMgm = PoolEntry<double>(3);
+  PoolEntry<double> rotRateTotSource = PoolEntry<double>(3);
   PoolEntry<uint8_t> rotRateSource = PoolEntry<uint8_t>();
 
   // Fused Rot Rate Sources

mission/controller/acs/AcsParameters.cpp

@@ -38,6 +38,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0x5:
           parameterWrapper->set(onBoardParams.questFilterWeight);
           break;
+        case 0x6:
+          parameterWrapper->set(onBoardParams.questAngleLimit);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }

mission/controller/acs/AcsParameters.h

@@ -26,6 +26,7 @@ class AcsParameters : public HasParametersIF {
     uint8_t fusedRateFromStr = true;
     uint8_t fusedRateFromQuest = true;
     double questFilterWeight = 0.9;
+    double questAngleLimit = 5 * DEG2RAD;
   } onBoardParams;
 
   struct InertiaEIVE {
@@ -949,7 +950,7 @@ class AcsParameters : public HasParametersIF {
     double sensorNoiseGyrArw = 3. * 0.0043 / sqrt(10) * DEG2RAD;  // Angular Random Walk
     double sensorNoiseGyrBs = 3. / 3600. * DEG2RAD;               // Bias Stability
 
-    uint8_t allowStr = false;
+    uint8_t allowStr = true;
   } kalmanFilterParameters;
 
   struct MagnetorquerParameter {

mission/controller/acs/AttitudeEstimation.cpp

@@ -29,6 +29,20 @@ void AttitudeEstimation::quest(acsctrl::SusDataProcessed *susData,
   VectorOperations<double>::normalize(mgmData->mgmVecTot.value, normMgmB, 3);
   VectorOperations<double>::normalize(mgmData->magIgrfModel.value, normMgmI, 3);
 
+  if ((std::acos(VectorOperations<double>::dot(normSusB, normMgmB)) <
+       acsParameters->onBoardParams.questAngleLimit) or
+      (std::acos(VectorOperations<double>::dot(normSusI, normMgmI)) <
+       acsParameters->onBoardParams.questAngleLimit)) {
+    {
+      PoolReadGuard pg{attitudeEstimationData};
+      if (pg.getReadResult() == returnvalue::OK) {
+        std::memcpy(attitudeEstimationData->quatQuest.value, ZERO_VEC4, 4 * sizeof(double));
+        attitudeEstimationData->quatQuest.setValid(false);
+      }
+    }
+    return;
+  }
+
   // Create Helper Vectors
   double normHelperB[3] = {0, 0, 0}, normHelperI[3] = {0, 0, 0}, helperCross[3] = {0, 0, 0},
          helperSum[3] = {0, 0, 0};

mission/controller/acs/FusedRotationEstimation.cpp

@@ -19,13 +19,9 @@ void FusedRotationEstimation::estimateFusedRotationRate(
                                            acsParameters->onBoardParams.fusedRateFromStr)) {
     PoolReadGuard pg(fusedRotRateData);
     if (pg.getReadResult() == returnvalue::OK) {
-      std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC3, 3 * sizeof(double));
-      fusedRotRateData->rotRateOrthogonal.setValid(false);
-      std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC3, 3 * sizeof(double));
-      fusedRotRateData->rotRateParallel.setValid(false);
-      std::memcpy(fusedRotRateData->rotRateTotal.value,
+      std::memcpy(fusedRotRateData->rotRateTotalSource.value,
                   fusedRotRateSourcesData->rotRateTotalStr.value, 3 * sizeof(double));
-      fusedRotRateData->rotRateTotal.setValid(true);
+      fusedRotRateData->rotRateTotalSource.setValid(true);
       fusedRotRateData->rotRateSource.value = acs::rotrate::Source::STR;
       fusedRotRateData->rotRateSource.setValid(true);
     }
@@ -34,41 +30,38 @@ void FusedRotationEstimation::estimateFusedRotationRate(
               acsParameters->onBoardParams.fusedRateFromQuest)) {
     PoolReadGuard pg(fusedRotRateData);
     if (pg.getReadResult() == returnvalue::OK) {
-      std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC3, 3 * sizeof(double));
-      fusedRotRateData->rotRateOrthogonal.setValid(false);
-      std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC3, 3 * sizeof(double));
-      fusedRotRateData->rotRateParallel.setValid(false);
-      std::memcpy(fusedRotRateData->rotRateTotal.value,
+      std::memcpy(fusedRotRateData->rotRateTotalSource.value,
                   fusedRotRateSourcesData->rotRateTotalQuest.value, 3 * sizeof(double));
-      fusedRotRateData->rotRateTotal.setValid(true);
+      fusedRotRateData->rotRateTotalSource.setValid(true);
       fusedRotRateData->rotRateSource.value = acs::rotrate::Source::QUEST;
       fusedRotRateData->rotRateSource.setValid(true);
     }
   } else if (fusedRotRateSourcesData->rotRateTotalSusMgm.isValid()) {
-    std::memcpy(fusedRotRateData->rotRateOrthogonal.value,
-                fusedRotRateSourcesData->rotRateOrthogonalSusMgm.value, 3 * sizeof(double));
-    fusedRotRateData->rotRateOrthogonal.setValid(
-        fusedRotRateSourcesData->rotRateOrthogonalSusMgm.isValid());
-    std::memcpy(fusedRotRateData->rotRateParallel.value,
-                fusedRotRateSourcesData->rotRateParallelSusMgm.value, 3 * sizeof(double));
-    fusedRotRateData->rotRateParallel.setValid(
-        fusedRotRateSourcesData->rotRateParallelSusMgm.isValid());
-    std::memcpy(fusedRotRateData->rotRateTotal.value,
+    std::memcpy(fusedRotRateData->rotRateTotalSource.value,
                 fusedRotRateSourcesData->rotRateTotalSusMgm.value, 3 * sizeof(double));
-    fusedRotRateData->rotRateTotal.setValid(true);
+    fusedRotRateData->rotRateTotalSource.setValid(true);
     fusedRotRateData->rotRateSource.value = acs::rotrate::Source::SUSMGM;
     fusedRotRateData->rotRateSource.setValid(true);
   } else {
     PoolReadGuard pg(fusedRotRateData);
     if (pg.getReadResult() == returnvalue::OK) {
-      std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC3, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC3, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateTotal.value, ZERO_VEC3, 3 * sizeof(double));
-      fusedRotRateData->setValidity(false, true);
+      std::memcpy(fusedRotRateData->rotRateTotalSource.value, ZERO_VEC3, 3 * sizeof(double));
+      fusedRotRateData->rotRateTotalSource.setValid(false);
       fusedRotRateData->rotRateSource.value = acs::rotrate::Source::NONE;
       fusedRotRateData->rotRateSource.setValid(true);
     }
   }
+  if (fusedRotRateSourcesData->rotRateTotalSusMgm.isValid()) {
+    std::memcpy(fusedRotRateData->rotRateTotalSusMgm.value,
+                fusedRotRateSourcesData->rotRateTotalSusMgm.value, 3 * sizeof(double));
+    fusedRotRateData->rotRateTotalSusMgm.setValid(true);
+  } else {
+    PoolReadGuard pg(fusedRotRateData);
+    if (pg.getReadResult() == returnvalue::OK) {
+      std::memcpy(fusedRotRateData->rotRateTotalSusMgm.value, ZERO_VEC3, 3 * sizeof(double));
+      fusedRotRateData->rotRateTotalSusMgm.setValid(false);
+    }
+  }
 }
 
 void FusedRotationEstimation::estimateFusedRotationRateStr(

mission/controller/controllerdefinitions/AcsCtrlDefinitions.h

@@ -129,9 +129,8 @@ enum PoolIds : lp_id_t {
   RW_TARGET_SPEED,
   MTQ_TARGET_DIPOLE,
   // Fused Rotation Rate
-  ROT_RATE_ORTHOGONAL,
-  ROT_RATE_PARALLEL,
-  ROT_RATE_TOTAL,
+  ROT_RATE_TOT_SUSMGM,
+  ROT_RATE_TOT_SOURCE,
   ROT_RATE_SOURCE,
   // Fused Rotation Rate Sources
   ROT_RATE_ORTHOGONAL_SUSMGM,
@@ -151,7 +150,7 @@ static constexpr uint8_t GPS_SET_PROCESSED_ENTRIES = 6;
 static constexpr uint8_t ATTITUDE_ESTIMATION_SET_ENTRIES = 4;
 static constexpr uint8_t CTRL_VAL_SET_ENTRIES = 5;
 static constexpr uint8_t ACT_CMD_SET_ENTRIES = 3;
-static constexpr uint8_t FUSED_ROT_RATE_SET_ENTRIES = 4;
+static constexpr uint8_t FUSED_ROT_RATE_SET_ENTRIES = 3;
 static constexpr uint8_t FUSED_ROT_RATE_SOURCES_SET_ENTRIES = 5;
 
 /**
@@ -318,10 +317,10 @@ class FusedRotRateData : public StaticLocalDataSet<FUSED_ROT_RATE_SET_ENTRIES> {
   FusedRotRateData(HasLocalDataPoolIF* hkOwner)
       : StaticLocalDataSet(hkOwner, FUSED_ROTATION_RATE_DATA) {}
 
-  lp_vec_t<double, 3> rotRateOrthogonal =
-      lp_vec_t<double, 3>(sid.objectId, ROT_RATE_ORTHOGONAL, this);
-  lp_vec_t<double, 3> rotRateParallel = lp_vec_t<double, 3>(sid.objectId, ROT_RATE_PARALLEL, this);
-  lp_vec_t<double, 3> rotRateTotal = lp_vec_t<double, 3>(sid.objectId, ROT_RATE_TOTAL, this);
+  lp_vec_t<double, 3> rotRateTotalSusMgm =
+      lp_vec_t<double, 3>(sid.objectId, ROT_RATE_TOT_SUSMGM, this);
+  lp_vec_t<double, 3> rotRateTotalSource =
+      lp_vec_t<double, 3>(sid.objectId, ROT_RATE_TOT_SOURCE, this);
   lp_var_t<uint8_t> rotRateSource = lp_var_t<uint8_t>(sid.objectId, ROT_RATE_SOURCE, this);
 
  private:

mission/system/acs/acsModeTree.cpp

@@ -105,7 +105,7 @@ Subsystem& satsystem::acs::init() {
   };
   // Build TARGET PT transition 0
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_PTG_TRANS_0.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TRANS_0.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TRANS_0.second, true);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_PTG_TRANS_0.second);
@@ -114,7 +114,7 @@ Subsystem& satsystem::acs::init() {
         ctxc);
 
   // Build SUS board transition
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, SUS_BOARD_NML_TRANS.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, SUS_BOARD_NML_TRANS.second, true);
   check(ACS_SUBSYSTEM.addTable(TableEntry(SUS_BOARD_NML_TRANS.first, &SUS_BOARD_NML_TRANS.second)),
         ctxc);
 
@@ -200,14 +200,14 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::ACS_CONTROLLER, acs::AcsMode::SAFE, acs::SafeSubmode::DEFAULT,
       ACS_TABLE_SAFE_TGT.second, true);
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_SAFE_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_SAFE_TGT.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_SAFE_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_SAFE_TGT.second, true);
   check(ss.addTable(&ACS_TABLE_SAFE_TGT.second, ACS_TABLE_SAFE_TGT.first, false, true), ctxc);
 
   // Build SAFE transition 0
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_SAFE_TRANS_0.second);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_SAFE_TRANS_0.second, true);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_SAFE_TRANS_0.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_SAFE_TRANS_0.second, true);
   iht(objects::STR_ASSY, OFF, 0, ACS_TABLE_SAFE_TRANS_0.second);
   iht(objects::RW_ASSY, OFF, 0, ACS_TABLE_SAFE_TRANS_0.second);
   check(ss.addTable(&ACS_TABLE_SAFE_TRANS_0.second, ACS_TABLE_SAFE_TRANS_0.first, false, true),
@@ -257,14 +257,14 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_IDLE_TGT.second);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_IDLE_TGT.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_IDLE_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_IDLE_TGT.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_IDLE_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_IDLE_TGT.second, true);
   ss.addTable(&ACS_TABLE_IDLE_TGT.second, ACS_TABLE_IDLE_TGT.first, false, true);
 
   // Build IDLE transition 0
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_IDLE_TRANS_0.second, true);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_IDLE_TRANS_0.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_IDLE_TRANS_0.second, true);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_IDLE_TRANS_0.second);
   ss.addTable(&ACS_TABLE_IDLE_TRANS_0.second, ACS_TABLE_IDLE_TRANS_0.first, false, true);
@@ -307,7 +307,7 @@ void buildTargetPtSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TARGET PT table
   iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_TARGET, 0, ACS_TABLE_PTG_TARGET_TGT.second);
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_PTG_TARGET_TGT.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_TGT.second, true);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second);
@@ -356,7 +356,7 @@ void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TARGET PT table
   iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_NADIR, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_PTG_TARGET_NADIR_TGT.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_NADIR_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_NADIR_TGT.second, true);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
@@ -409,7 +409,7 @@ void buildTargetPtGsSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TARGET PT table
   iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_TARGET_GS, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_PTG_TARGET_GS_TGT.second, true);
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_GS_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_GS_TGT.second, true);
   iht(objects::RW_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
   iht(objects::STR_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
@@ -462,7 +462,7 @@ void buildTargetPtInertialSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_INERTIAL, 0,
       ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
   iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second,
+  iht(objects::SUS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second,
       true);
   iht(objects::ACS_BOARD_ASS, NML, duallane::B_SIDE, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second,
       true);