Merge remote-tracking branch 'origin/develop' into feature_move_acs_event_handling_to_system

CHANGELOG.md

@@ -28,6 +28,10 @@ will consitute of a breaking change warranting a new major release:
   sometimes blocking for a long time.
 - Request raw MTM measurement twice for IMTQ, might reduce number of times measurement could not
   be retrieved.
+- Event manager and event service have larger queues now: 45 -> 120 for Service 5, 80 -> 120 for
+  event manager
+- ACS mode changes: The ACS CTRL submodes are now modes. DETUBMLE is now submode of SAFE mode.
+- EIVE system now tracks the mode of the ACS subsyste in SAFE mode.
 
 # [v1.36.0] 2023-03-08
 

mission/acsDefs.cpp

@@ -11,10 +11,6 @@ const char* acs::getModeStr(AcsMode mode) {
       modeStr = "SAFE";
       break;
     }
-    case (acs::AcsMode::DETUMBLE): {
-      modeStr = "DETUBMLE";
-      break;
-    }
     case (acs::AcsMode::PTG_NADIR): {
       modeStr = "POITNING NADIR";
       break;

mission/acsDefs.h

@@ -10,14 +10,15 @@ namespace acs {
 enum AcsMode : Mode_t {
   OFF = HasModesIF::MODE_OFF,
   SAFE = 10,
-  DETUMBLE = 11,
+  PTG_IDLE = 11,
-  PTG_IDLE = 12,
+  PTG_NADIR = 12,
-  PTG_NADIR = 13,
+  PTG_TARGET = 13,
-  PTG_TARGET = 14,
+  PTG_TARGET_GS = 14,
-  PTG_TARGET_GS = 15,
+  PTG_INERTIAL = 15,
-  PTG_INERTIAL = 16,
 };
 
+enum SafeSubmode : Submode_t { DEFAULT = 0, DETUMBLE = 1 };
+
 // static constexpr uint8_t ACS_SYSTEM_DETUMBLE_SUBMODE = 1;
 
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;

mission/controller/AcsController.cpp

@@ -112,12 +112,16 @@ void AcsController::performControlOperation() {
     }
     case InternalState::READY: {
       if (mode != MODE_OFF) {
-        switch (submode) {
+        switch (mode) {
           case acs::SAFE:
-            performSafe();
+            switch (submode) {
-            break;
+              case SUBMODE_NONE:
-          case acs::DETUMBLE:
+                performSafe();
-            performDetumble();
+                break;
+              case acs::DETUMBLE:
+                performDetumble();
+                break;
+            }
             break;
           case acs::PTG_IDLE:
           case acs::PTG_TARGET:
@@ -636,8 +640,14 @@ ReturnValue_t AcsController::checkModeCommand(Mode_t mode, Submode_t submode,
     } else {
       return INVALID_SUBMODE;
     }
-  } else if ((mode == MODE_ON) || (mode == MODE_NORMAL)) {
+  } else if (not((mode < acs::AcsMode::SAFE) or (mode > acs::AcsMode::PTG_INERTIAL))) {
-    if ((submode < acs::AcsMode::SAFE) or (submode > acs::AcsMode::PTG_INERTIAL)) {
+    if (mode == acs::AcsMode::SAFE) {
+      if (not((submode == SUBMODE_NONE) or (submode == acs::SafeSubmode::DETUMBLE))) {
+        return INVALID_SUBMODE;
+      } else {
+        return returnvalue::OK;
+      }
+    } else if (not(submode == SUBMODE_NONE)) {
       return INVALID_SUBMODE;
     } else {
       return returnvalue::OK;
@@ -654,12 +664,19 @@ void AcsController::announceMode(bool recursive) {
   const char *modeStr = "UNKNOWN";
   if (mode == HasModesIF::MODE_OFF) {
     modeStr = "OFF";
-  } else if (mode == HasModesIF::MODE_ON) {
+  } else {
-    modeStr = "ON";
+    modeStr = acs::getModeStr(static_cast<acs::AcsMode>(mode));
-  } else if (mode == DeviceHandlerIF::MODE_NORMAL) {
+  }
-    modeStr = "NORMAL";
+  const char *submodeStr = "UNKNOWN";
+  if (submode == HasModesIF::SUBMODE_NONE) {
+    submodeStr = "NONE";
+  }
+  if (mode == acs::AcsMode::SAFE) {
+    acs::SafeSubmode safeSubmode = static_cast<acs::SafeSubmode>(this->submode);
+    if (safeSubmode == acs::SafeSubmode::DETUMBLE) {
+      submodeStr = "DETUMBLE";
+    }
   }
-  const char *submodeStr = acs::getModeStr(static_cast<acs::AcsMode>(submode));
   sif::info << "ACS controller is now in " << modeStr << " mode with " << submodeStr << " submode"
             << std::endl;
   return ExtendedControllerBase::announceMode(recursive);

mission/core/GenericFactory.cpp

@@ -86,7 +86,7 @@ EiveFaultHandler EIVE_FAULT_HANDLER;
 void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
                                           CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan) {
   // Framework objects
-  new EventManager(objects::EVENT_MANAGER);
+  new EventManager(objects::EVENT_MANAGER, 120);
   auto healthTable = new HealthTable(objects::HEALTH_TABLE);
   if (healthTable_ != nullptr) {
     *healthTable_ = healthTable;
@@ -162,14 +162,14 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
 
   // PUS service stack
   new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, config::EIVE_PUS_APID,
-                                      pus::PUS_SERVICE_1, objects::PUS_TM_FUNNEL, 20);
+                                      pus::PUS_SERVICE_1, objects::PUS_TM_FUNNEL, 40);
   new Service2DeviceAccess(objects::PUS_SERVICE_2_DEVICE_ACCESS, config::EIVE_PUS_APID,
                            pus::PUS_SERVICE_2, 3, 10);
   new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, config::EIVE_PUS_APID,
                            pus::PUS_SERVICE_3);
   new Service5EventReporting(
       PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, config::EIVE_PUS_APID, pus::PUS_SERVICE_5),
-      15, 45);
+      15, 120);
   new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, config::EIVE_PUS_APID,
                                  pus::PUS_SERVICE_8, 16, 60);
   new Service9TimeManagement(

mission/system/objects/EiveSystem.cpp

@@ -23,10 +23,6 @@ void EiveSystem::announceMode(bool recursive) {
       modeStr = "SAFE";
       break;
     }
-    case (acs::AcsMode::DETUMBLE): {
-      modeStr = "DETUBMLE";
-      break;
-    }
     case (acs::AcsMode::PTG_IDLE): {
       modeStr = "POINTING IDLE";
       break;

mission/system/tree/acsModeTree.cpp

@@ -20,7 +20,6 @@ namespace {
 const auto check = subsystem::checkInsert;
 
 void buildOffSequence(Subsystem& ss, ModeListEntry& eh);
-void buildDetumbleSequence(Subsystem& ss, ModeListEntry& entryHelper);
 void buildSafeSequence(Subsystem& ss, ModeListEntry& entryHelper);
 void buildIdleSequence(Subsystem& ss, ModeListEntry& entryHelper);
 void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh);
@@ -43,15 +42,6 @@ auto ACS_TABLE_OFF_TRANS_0 =
 auto ACS_TABLE_OFF_TRANS_1 =
     std::make_pair((acs::AcsMode::OFF << 24) | 3, FixedArrayList<ModeListEntry, 6>());
 
-auto ACS_SEQUENCE_DETUMBLE =
-    std::make_pair(acs::AcsMode::DETUMBLE, FixedArrayList<ModeListEntry, 4>());
-auto ACS_TABLE_DETUMBLE_TGT =
-    std::make_pair((acs::AcsMode::DETUMBLE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
-auto ACS_TABLE_DETUMBLE_TRANS_0 =
-    std::make_pair((acs::AcsMode::DETUMBLE << 24) | 2, FixedArrayList<ModeListEntry, 5>());
-auto ACS_TABLE_DETUMBLE_TRANS_1 =
-    std::make_pair((acs::AcsMode::DETUMBLE << 24) | 3, FixedArrayList<ModeListEntry, 5>());
-
 auto ACS_SEQUENCE_SAFE = std::make_pair(acs::AcsMode::SAFE, FixedArrayList<ModeListEntry, 4>());
 auto ACS_TABLE_SAFE_TGT =
     std::make_pair((acs::AcsMode::SAFE << 24) | 1, FixedArrayList<ModeListEntry, 4>());
@@ -130,7 +120,6 @@ Subsystem& satsystem::acs::init() {
 
   buildOffSequence(ACS_SUBSYSTEM, entry);
   buildSafeSequence(ACS_SUBSYSTEM, entry);
-  buildDetumbleSequence(ACS_SUBSYSTEM, entry);
   buildIdleSequence(ACS_SUBSYSTEM, entry);
   buildTargetPtSequence(ACS_SUBSYSTEM, entry);
   buildTargetPtGsSequence(ACS_SUBSYSTEM, entry);
@@ -206,8 +195,9 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
     eh.setCheckSuccess(checkSuccess);
     check(sequence.insert(eh), ctxc);
   };
-  // Build SAFE target
+  // Build SAFE target. Allow detumble submode.
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::SAFE, ACS_TABLE_SAFE_TGT.second);
+  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, 0, ACS_TABLE_SAFE_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_SAFE_TGT.second, true);
@@ -225,7 +215,8 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
   // SUS board transition table is defined above
 
   // Build SAFE transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::SAFE, ACS_TABLE_SAFE_TRANS_1.second);
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::SAFE, acs::SafeSubmode::DEFAULT,
+      ACS_TABLE_SAFE_TRANS_1.second);
   check(ss.addTable(&ACS_TABLE_SAFE_TRANS_1.second, ACS_TABLE_SAFE_TRANS_1.first, false, true),
         ctxc);
 
@@ -238,61 +229,6 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
         ctxc);
 }
 
-void buildDetumbleSequence(Subsystem& ss, ModeListEntry& eh) {
-  std::string context = "satsystem::acs::buildDetumbleSequence";
-  auto ctxc = context.c_str();
-  // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode,
-                 ArrayList<ModeListEntry>& sequence, bool allowAllSubmodes = false) {
-    eh.setObject(obj);
-    eh.setMode(mode);
-    eh.setSubmode(submode);
-    if (allowAllSubmodes) {
-      eh.allowAllSubmodes();
-    }
-    check(sequence.insert(eh), ctxc);
-  };
-  // Insert Helper Sequence
-  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
-                 bool checkSuccess) {
-    eh.setTableId(tableId);
-    eh.setWaitSeconds(waitSeconds);
-    eh.setCheckSuccess(checkSuccess);
-    check(sequence.insert(eh), ctxc);
-  };
-  // Build DETUMBLE target
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::DETUMBLE, ACS_TABLE_DETUMBLE_TGT.second);
-  iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_DETUMBLE_TGT.second);
-  iht(objects::SUS_BOARD_ASS, NML, 0, ACS_TABLE_DETUMBLE_TGT.second, true);
-  iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_DETUMBLE_TGT.second, true);
-  check(ss.addTable(&ACS_TABLE_DETUMBLE_TGT.second, ACS_TABLE_DETUMBLE_TGT.first, false, true),
-        ctxc);
-
-  // Build DETUMBLE transition 0
-  iht(objects::IMTQ_ASSY, NML, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
-  iht(objects::ACS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_DETUMBLE_TRANS_0.second, true);
-  iht(objects::SUS_BOARD_ASS, NML, duallane::A_SIDE, ACS_TABLE_DETUMBLE_TRANS_0.second, true);
-  iht(objects::STR_ASSY, OFF, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
-  iht(objects::RW_ASSY, OFF, 0, ACS_TABLE_DETUMBLE_TRANS_0.second);
-  check(ss.addTable(&ACS_TABLE_DETUMBLE_TRANS_0.second, ACS_TABLE_DETUMBLE_TRANS_0.first, false,
-                    true),
-        ctxc);
-
-  // Build DETUMBLE transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::DETUMBLE, ACS_TABLE_DETUMBLE_TRANS_1.second);
-  check(ss.addTable(&ACS_TABLE_DETUMBLE_TRANS_1.second, ACS_TABLE_DETUMBLE_TRANS_1.first, false,
-                    true),
-        ctxc);
-
-  // Build DETUMBLE sequence
-  ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TGT.first, 0, true);
-  ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TRANS_0.first, 0, false);
-  ihs(ACS_SEQUENCE_DETUMBLE.second, ACS_TABLE_DETUMBLE_TRANS_1.first, 0, false);
-  check(ss.addSequence(&ACS_SEQUENCE_DETUMBLE.second, ACS_SEQUENCE_DETUMBLE.first,
-                       ACS_SEQUENCE_SAFE.first, false, true),
-        ctxc);
-}
-
 void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::acs::buildIdleSequence";
   auto ctxc = context.c_str();
@@ -316,7 +252,7 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
     check(sequence.insert(eh), ctxc);
   };
   // Build IDLE target
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_IDLE, ACS_TABLE_IDLE_TGT.second);
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_IDLE, 0, 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);
@@ -333,7 +269,7 @@ void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
   ss.addTable(&ACS_TABLE_IDLE_TRANS_0.second, ACS_TABLE_IDLE_TRANS_0.first, false, true);
 
   // Build IDLE transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_IDLE, ACS_TABLE_IDLE_TRANS_1.second);
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_IDLE, 0, ACS_TABLE_IDLE_TRANS_1.second);
   ss.addTable(&ACS_TABLE_IDLE_TRANS_1.second, ACS_TABLE_IDLE_TRANS_1.first, false, true);
 
   // Build IDLE sequence
@@ -368,7 +304,7 @@ void buildTargetPtSequence(Subsystem& ss, ModeListEntry& eh) {
   };
 
   // Build TARGET PT table
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_TARGET, ACS_TABLE_PTG_TARGET_TGT.second);
+  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, 0, ACS_TABLE_PTG_TARGET_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_TGT.second, true);
@@ -379,7 +315,7 @@ void buildTargetPtSequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Transition 0 already built
   // Build TARGET PT transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_TARGET, ACS_TABLE_PTG_TARGET_TRANS_1.second);
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_TARGET, 0, ACS_TABLE_PTG_TARGET_TRANS_1.second);
   check(ss.addTable(&ACS_TABLE_PTG_TARGET_TRANS_1.second, ACS_TABLE_PTG_TARGET_TRANS_1.first, false,
                     true),
         ctxc);
@@ -417,8 +353,7 @@ void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh) {
   };
 
   // Build TARGET PT table
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_TARGET,
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_NADIR, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second);
-      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, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_NADIR_TGT.second, true);
@@ -430,7 +365,7 @@ void buildTargetPtNadirSequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Transition 0 already built
   // Build TARGET PT transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_NADIR,
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_NADIR, 0,
       ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.second);
   check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.first,
                                &ACS_TABLE_PTG_TARGET_NADIR_TRANS_1.second)),
@@ -471,8 +406,7 @@ void buildTargetPtGsSequence(Subsystem& ss, ModeListEntry& eh) {
   };
 
   // Build TARGET PT table
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_TARGET_GS,
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_TARGET_GS, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second);
-      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, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second, true);
   iht(objects::ACS_BOARD_ASS, NML, 0, ACS_TABLE_PTG_TARGET_GS_TGT.second, true);
@@ -484,7 +418,7 @@ void buildTargetPtGsSequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Transition 0 already built
   // Build TARGET PT transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_TARGET_GS,
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_TARGET_GS, 0,
       ACS_TABLE_PTG_TARGET_GS_TRANS_1.second);
   check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_GS_TRANS_1.first,
                                &ACS_TABLE_PTG_TARGET_GS_TRANS_1.second)),
@@ -524,7 +458,7 @@ void buildTargetPtInertialSequence(Subsystem& ss, ModeListEntry& eh) {
   };
 
   // Build TARGET PT table
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_INERTIAL,
+  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, 0, ACS_TABLE_PTG_TARGET_INERTIAL_TGT.second, true);
@@ -537,7 +471,7 @@ void buildTargetPtInertialSequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Transition 0 already built
   // Build TARGET PT transition 1
-  iht(objects::ACS_CONTROLLER, NML, acs::AcsMode::PTG_INERTIAL,
+  iht(objects::ACS_CONTROLLER, acs::AcsMode::PTG_INERTIAL, 0,
       ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.second);
   check(ss.addTable(TableEntry(ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.first,
                                &ACS_TABLE_PTG_TARGET_INERTIAL_TRANS_1.second)),

mission/system/tree/system.cpp

@@ -82,11 +82,8 @@ void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
     check(sequence.insert(eh), ctxc);
   };
 
-  // Do no track ACS for now because it might jump to detumble mode and back to safe as part of
+  // Do no track submode to allow transitions to DETUMBLE submode.
-  // normal operations.
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
-  // UPDATE: This could be re-enabled as soon as the detumble mode is a submode of
-  // ACS CTRL safe mode.
-  // 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);