bsp_q7s/core/ObjectFactory.cpp

@@ -7,6 +7,7 @@
 #include <mission/devices/GyrL3gCustomHandler.h>
 #include <mission/devices/MgmLis3CustomHandler.h>
 #include <mission/devices/MgmRm3100CustomHandler.h>
+#include <mission/system/fdir/StrFdir.h>
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/objects/ImtqAssembly.h>
 #include <mission/system/objects/StrAssembly.h>
@@ -925,11 +926,13 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   if (paramJsonFile == nullptr) {
     sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
   }
+  auto strFdir = new StrFdir(objects::STAR_TRACKER);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
                              paramJsonFile, strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(*strAssy);
+  starTracker->setCustomFdir(strFdir);
 }
 
 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {

linux/devices/startracker/StarTrackerHandler.cpp

@@ -1677,7 +1677,7 @@ void StarTrackerHandler::prepareHistogramRequest() {
 ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
                                                       size_t commandDataLen,
                                                       ArcsecJsonParamBase& paramSet) {
-  Stopwatch watch;
+  // Stopwatch watch;
   ReturnValue_t result = returnvalue::OK;
   if (commandDataLen > MAX_PATH_SIZE) {
     return FILE_PATH_TOO_LONG;

mission/acsDefs.h

@@ -18,6 +18,8 @@ enum AcsMode : Mode_t {
   PTG_INERTIAL = 16,
 };
 
+// static constexpr uint8_t ACS_SYSTEM_DETUMBLE_SUBMODE = 1;
+
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;
 //!< The limits for the rotation in safe mode were violated.
 static const Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);

mission/controller/AcsController.cpp

@@ -264,8 +264,9 @@ void AcsController::performPointingCtrl() {
       triggerEvent(acs::MEKF_INVALID_INFO);
       mekfInvalidFlag = true;
     }
-    if (mekfInvalidCounter > 4) {
+    if (mekfInvalidCounter == 5) {
-      triggerEvent(acs::MEKF_INVALID_MODE_VIOLATION);
+      // Trigger this so STR FDIR can set the device faulty.
+      EventManagerIF::triggerEvent(objects::STAR_TRACKER, acs::MEKF_INVALID_MODE_VIOLATION, 0, 0);
     }
     mekfInvalidCounter++;
     //    commandActuators(0, 0, 0, acsParameters.magnetorquesParameter.torqueDuration,
@@ -281,7 +282,7 @@ void AcsController::performPointingCtrl() {
   double rwPseudoInv[4][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
   result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
   if (result == returnvalue::FAILED) {
-    if (multipleRwUnavailableCounter > 4) {
+    if (multipleRwUnavailableCounter == 5) {
       triggerEvent(acs::MULTIPLE_RW_INVALID);
     }
     multipleRwUnavailableCounter++;

mission/controller/AcsController.h

@@ -4,6 +4,7 @@
 #include <eive/objects.h>
 #include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/globalfunctions/math/VectorOperations.h>
+#include <fsfw/health/HealthTable.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
 #include <fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h>

mission/devices/RwHandler.cpp

@@ -366,9 +366,8 @@ void RwHandler::handleGetRwStatusReply(const uint8_t* packet) {
   statusSet.setValidity(true, true);
 
   if (statusSet.state == rws::STATE_ERROR) {
-    // This requires the commanding of the init reaction wheel controller command to recover
+    // Trigger FDIR reaction, first recovery, then faulty if it doesnt fix the issue.
-    // from error state which must be handled by the FDIR instance.
+    triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT, statusSet.state.value, 0);
-    triggerEvent(rws::ERROR_STATE, statusSet.state.value, 0);
     sif::error << "RwHandler::handleGetRwStatusReply: Reaction wheel in error state" << std::endl;
   }
 

mission/system/fdir/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(
-  ${LIB_EIVE_MISSION} PRIVATE AcsBoardFdir.cpp RtdFdir.cpp SusFdir.cpp
+  ${LIB_EIVE_MISSION}
-                              SyrlinksFdir.cpp GomspacePowerFdir.cpp)
+  PRIVATE AcsBoardFdir.cpp RtdFdir.cpp StrFdir.cpp SusFdir.cpp SyrlinksFdir.cpp
+          GomspacePowerFdir.cpp)

mission/system/fdir/StrFdir.cpp

@@ -0,0 +1,14 @@
+#include "StrFdir.h"
+
+#include "mission/acsDefs.h"
+
+StrFdir::StrFdir(object_id_t strObject)
+    : DeviceHandlerFailureIsolation(strObject, objects::NO_OBJECT) {}
+
+ReturnValue_t StrFdir::eventReceived(EventMessage* event) {
+  if (event->getEvent() == acs::MEKF_INVALID_MODE_VIOLATION) {
+    setFaulty(event->getEvent());
+    return returnvalue::OK;
+  }
+  return DeviceHandlerFailureIsolation::eventReceived(event);
+}

mission/system/fdir/StrFdir.h

@@ -0,0 +1,12 @@
+#ifndef MISSION_SYSTEM_FDIR_STRFDIR_H_
+#define MISSION_SYSTEM_FDIR_STRFDIR_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerFailureIsolation.h>
+
+class StrFdir : public DeviceHandlerFailureIsolation {
+ public:
+  StrFdir(object_id_t strObject);
+  ReturnValue_t eventReceived(EventMessage* event) override;
+};
+
+#endif /* MISSION_SYSTEM_FDIR_STRFDIR_H_ */

mission/system/objects/AcsSubsystem.cpp

@@ -75,9 +75,7 @@ void AcsSubsystem::handleEventMessages() {
             sif::error << "AcsSubsystem: sending DETUMBLE mode cmd to self has failed" << std::endl;
           }
         }
-        if (event.getEvent() == acs::SAFE_RATE_RECOVERY ||
+        if (event.getEvent() == acs::SAFE_RATE_RECOVERY) {
-            event.getEvent() == acs::MULTIPLE_RW_INVALID ||
-            event.getEvent() == acs::MEKF_INVALID_MODE_VIOLATION) {
           CommandMessage msg;
           ModeMessage::setCmdModeMessage(msg, acs::AcsMode::SAFE, 0);
           status = commandQueue->sendMessage(commandQueue->getId(), &msg);

mission/system/tree/acsModeTree.cpp

@@ -319,6 +319,7 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_IDLE, ACS_TABLE_IDLE_TGT.second);
   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, 0, ACS_TABLE_IDLE_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_IDLE_TGT.second, true);
   ss.addTable(&ACS_TABLE_IDLE_TGT.second, ACS_TABLE_IDLE_TGT.first, false, true);

mission/system/tree/system.cpp

@@ -62,10 +62,14 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::buildSafeSequence";
   auto ctxc = context.c_str();
   // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table,
+                 bool allowAllSubmodes = false) {
     eh.setObject(obj);
     eh.setMode(mode);
     eh.setSubmode(submode);
+    if (allowAllSubmodes) {
+      eh.allowAllSubmodes();
+    }
     check(table.insert(eh), ctxc);
   };
   // Insert Helper Sequence
@@ -79,7 +83,7 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Do no track ACS for now because it might jump to detumble mode and back to safe as part of
   // normal operations.
-  // iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second);
+  // iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
   iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TGT.second);
   check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
 
@@ -88,18 +92,13 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_SAFE_TRANS_0.second);
   iht(objects::COM_SUBSYSTEM, com::RX_ONLY, 0, EIVE_TABLE_SAFE_TRANS_0.second);
   iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TRANS_0.second);
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TRANS_0.second, true);
   check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TRANS_0.first, &EIVE_TABLE_SAFE_TRANS_0.second)),
         ctxc);
 
-  // Build SAFE transition 1
-  // check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TRANS_1.first, &EIVE_TABLE_SAFE_TRANS_1.second)),
-  //      ctxc);
-
   // Build Safe sequence
   ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TGT.first, 0, false);
   ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TRANS_0.first, 0, false);
-  // ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TRANS_1.first, 0, false);
   check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_SAFE.first, &EIVE_SEQUENCE_SAFE.second,
                                      EIVE_SEQUENCE_SAFE.first)),
         ctxc);
@@ -127,21 +126,16 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TGT.second);
   check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
 
-  // Build SAFE transition 0
+  // Build IDLE transition 0
   iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_IDLE_TRANS_1.second);
+  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TRANS_1.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TRANS_0.second);
   check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TRANS_0.first, &EIVE_TABLE_IDLE_TRANS_0.second)),
         ctxc);
 
-  // Build SAFE transition 1
+  // Build IDLE sequence
-  // check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TRANS_1.first, &EIVE_TABLE_IDLE_TRANS_1.second)),
-  //     ctxc);
-
-  // Build Safe sequence
   ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TGT.first, 0, false);
   ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_0.first, 0, false);
-  // ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_1.first, 0, false);
   check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_IDLE.first, &EIVE_SEQUENCE_IDLE.second,
                                      EIVE_SEQUENCE_SAFE.first)),
         ctxc);