CHANGELOG.md

@@ -24,6 +24,11 @@ will consitute of a breaking change warranting a new major release:
 
 ## Fixed
 
+- Star Tracker: OFF to NORMAL transition now posssible. Requires FSFW bump which sets
+  transition source modes properly for those transitions.
+  FSFW PR: https://egit.irs.uni-stuttgart.de/eive/fsfw/pulls/131
+- Star Tracker JSON initialization is now done during object initization instead of redoing it
+  when building a command. This avoids missed deadlines issues in the ACS PST.
 - Allow arbitrary submodes for dual lane boards to avoid FDIR reactions of subsystem components.
   Bump FSFW to allow this.
 - PUS 15 was not scheduled

bsp_q7s/core/ObjectFactory.cpp

@@ -908,9 +908,23 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
                        startracker::MAX_FRAME_SIZE * 2 + 2, UartModes::NON_CANONICAL);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
+
+  const char* paramJsonFile = nullptr;
+#ifdef EGSE
+  paramJsonFile = "/home/pi/arcsec/json/flight-config.json";
+#else
+#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
+  paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
+#else
+  paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
+#endif
+#endif
+  if (paramJsonFile == nullptr) {
+    sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
+  }
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
-                             strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
+                             paramJsonFile, strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 }

fsfw

@@ -1 +1 @@
-Subproject commit 7f6ba5f40b47bc32802efdc4ed41b4bad4b8071b
+Subproject commit 1b7493f945302b3785ceba6e7a34a727e3898a13

linux/devices/startracker/ArcsecJsonParamBase.cpp

@@ -5,14 +5,14 @@
 ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {}
 
 ReturnValue_t ArcsecJsonParamBase::create(std::string fullname, uint8_t* buffer) {
-  ReturnValue_t result = returnvalue::OK;
+  // ReturnValue_t result = returnvalue::OK;
-  result = init(fullname);
+  //  result = init(fullname);
-  if (result != returnvalue::OK) {
+  //  if (result != returnvalue::OK) {
-    sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set "
+  //    sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set "
-                 << setName << std::endl;
+  //                 << setName << std::endl;
-    return result;
+  //    return result;
-  }
+  //  }
-  result = createCommand(buffer);
+  ReturnValue_t result = createCommand(buffer);
   if (result != returnvalue::OK) {
     sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set "
                  << setName << std::endl;
@@ -74,12 +74,17 @@ ReturnValue_t ArcsecJsonParamBase::init(const std::string filename) {
                  << std::endl;
     return JSON_FILE_NOT_EXISTS;
   }
+  try {
     createJsonObject(filename);
     result = initSet();
     if (result != returnvalue::OK) {
       return result;
     }
     return returnvalue::OK;
+  } catch (json::exception& e) {
+    // TODO: Re-create json file from backup here.
+    return returnvalue::FAILED;
+  }
 }
 
 void ArcsecJsonParamBase::createJsonObject(const std::string fullname) {

linux/devices/startracker/ArcsecJsonParamBase.h

@@ -41,6 +41,17 @@ class ArcsecJsonParamBase {
    */
   ArcsecJsonParamBase(std::string setName);
 
+  /**
+   * @brief   Initializes the properties json object and the set json object
+   *
+   * @param fullname  Name including absolute path to json file
+   * @param setName   The name of the set to work on
+   *
+   * @param return    JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise
+   *                  returnvalue::OK
+   */
+  ReturnValue_t init(const std::string filename);
+
   /**
    * @brief   Fills a buffer with a parameter set
    *
@@ -124,17 +135,6 @@ class ArcsecJsonParamBase {
    */
   virtual ReturnValue_t createCommand(uint8_t* buffer) = 0;
 
-  /**
-   * @brief   Initializes the properties json object and the set json object
-   *
-   * @param fullname  Name including absolute path to json file
-   * @param setName   The name of the set to work on
-   *
-   * @param return    JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise
-   *                  returnvalue::OK
-   */
-  ReturnValue_t init(const std::string filename);
-
   void createJsonObject(const std::string fullname);
 
   /**

linux/devices/startracker/StarTrackerHandler.cpp

@@ -1,8 +1,11 @@
 #include "StarTrackerHandler.h"
 
 #include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
 
+#include <atomic>
 #include <fstream>
+#include <thread>
 
 #include "OBSWConfig.h"
 #include "StarTrackerJsonCommands.h"
@@ -14,8 +17,11 @@ extern "C" {
 #include "common/misc.h"
 }
 
+std::atomic_bool JCFG_DONE(false);
+
 StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                                       StrHelper* strHelper, power::Switch_t powerSwitch)
+                                       const char* jsonFileStr, StrHelper* strHelper,
+                                       power::Switch_t powerSwitch)
     : DeviceHandlerBase(objectId, comIF, comCookie),
       temperatureSet(this),
       versionSet(this),
@@ -40,6 +46,7 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
       logSubscriptionSet(this),
       debugCameraSet(this),
       strHelper(strHelper),
+      paramJsonFile(jsonFileStr),
       powerSwitch(powerSwitch) {
   if (comCookie == nullptr) {
     sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
@@ -59,6 +66,11 @@ ReturnValue_t StarTrackerHandler::initialize() {
     return result;
   }
 
+  // Spin up a thread to do the JSON initialization, takes 200-250 ms which would
+  // delay whole satellite boot process.
+  jcfgCountdown.resetTimer();
+  jsonCfgTask = std::thread{setUpJsonCfgs, std::ref(jcfgs), paramJsonFile.c_str()};
+
   EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (manager == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -240,8 +252,19 @@ void StarTrackerHandler::doStartUp() {
       // the device handler's submode to the star tracker's mode
       return;
     case StartupState::DONE:
+      if (jcfgCountdown.isBusy()) {
+        startupState = StartupState::WAIT_JCFG;
+        return;
+      }
       startupState = StartupState::IDLE;
       break;
+    case StartupState::WAIT_JCFG: {
+      if (jcfgCountdown.hasTimedOut()) {
+        startupState = StartupState::IDLE;
+        break;
+      }
+      return;
+    }
     default:
       return;
   }
@@ -419,8 +442,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       return returnvalue::OK;
     }
     case (startracker::SUBSCRIPTION): {
-      Subscription subscription;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.subscription);
-      result = prepareParamCommand(commandData, commandDataLen, subscription);
       return returnvalue::OK;
     }
     case (startracker::REQ_SOLUTION): {
@@ -436,68 +458,55 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       return returnvalue::OK;
     }
     case (startracker::LIMITS): {
-      Limits limits;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.limits);
-      result = prepareParamCommand(commandData, commandDataLen, limits);
       return result;
     }
     case (startracker::MOUNTING): {
-      Mounting mounting;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.mounting);
-      result = prepareParamCommand(commandData, commandDataLen, mounting);
       return result;
     }
     case (startracker::IMAGE_PROCESSOR): {
-      ImageProcessor imageProcessor;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.imageProcessor);
-      result = prepareParamCommand(commandData, commandDataLen, imageProcessor);
       return result;
     }
     case (startracker::CAMERA): {
-      Camera camera;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.camera);
-      result = prepareParamCommand(commandData, commandDataLen, camera);
       return result;
     }
     case (startracker::CENTROIDING): {
-      Centroiding centroiding;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.centroiding);
-      result = prepareParamCommand(commandData, commandDataLen, centroiding);
       return result;
     }
     case (startracker::LISA): {
-      Lisa lisa;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.lisa);
-      result = prepareParamCommand(commandData, commandDataLen, lisa);
       return result;
     }
     case (startracker::MATCHING): {
-      Matching matching;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.matching);
-      result = prepareParamCommand(commandData, commandDataLen, matching);
       return result;
     }
     case (startracker::VALIDATION): {
-      Validation validation;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.validation);
-      result = prepareParamCommand(commandData, commandDataLen, validation);
       return result;
     }
     case (startracker::ALGO): {
-      Algo algo;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.algo);
-      result = prepareParamCommand(commandData, commandDataLen, algo);
       return result;
     }
     case (startracker::TRACKING): {
-      Tracking tracking;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.tracking);
-      result = prepareParamCommand(commandData, commandDataLen, tracking);
       return result;
     }
     case (startracker::LOGLEVEL): {
-      LogLevel logLevel;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel);
-      result = prepareParamCommand(commandData, commandDataLen, logLevel);
       return result;
     }
     case (startracker::LOGSUBSCRIPTION): {
-      LogSubscription logSubscription;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription);
-      result = prepareParamCommand(commandData, commandDataLen, logSubscription);
       return result;
     }
     case (startracker::DEBUG_CAMERA): {
-      DebugCamera debugCamera;
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.debugCamera);
-      result = prepareParamCommand(commandData, commandDataLen, debugCamera);
       return result;
     }
     case (startracker::CHECKSUM): {
@@ -746,6 +755,24 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) {
   }
 }
 
+void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonFile) {
+  cfgs.tracking.init(paramJsonFile);
+  cfgs.logLevel.init(paramJsonFile);
+  cfgs.logSubscription.init(paramJsonFile);
+  cfgs.debugCamera.init(paramJsonFile);
+  cfgs.algo.init(paramJsonFile);
+  cfgs.validation.init(paramJsonFile);
+  cfgs.matching.init(paramJsonFile);
+  cfgs.lisa.init(paramJsonFile);
+  cfgs.centroiding.init(paramJsonFile);
+  cfgs.camera.init(paramJsonFile);
+  cfgs.imageProcessor.init(paramJsonFile);
+  cfgs.mounting.init(paramJsonFile);
+  cfgs.limits.init(paramJsonFile);
+  cfgs.subscription.init(paramJsonFile);
+  JCFG_DONE = true;
+}
+
 void StarTrackerHandler::bootBootloader() {
   if (internalState == InternalState::IDLE) {
     internalState = InternalState::BOOT_BOOTLOADER;
@@ -1650,6 +1677,7 @@ void StarTrackerHandler::prepareHistogramRequest() {
 ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
                                                       size_t commandDataLen,
                                                       ArcsecJsonParamBase& paramSet) {
+  Stopwatch watch;
   ReturnValue_t result = returnvalue::OK;
   if (commandDataLen > MAX_PATH_SIZE) {
     return FILE_PATH_TOO_LONG;

linux/devices/startracker/StarTrackerHandler.h

@@ -2,6 +2,9 @@
 #define MISSION_DEVICES_STARTRACKERHANDLER_H_
 
 #include <fsfw/datapool/PoolReadGuard.h>
+#include <linux/devices/startracker/StarTrackerJsonCommands.h>
+
+#include <thread>
 
 #include "ArcsecDatalinkLayer.h"
 #include "ArcsecJsonParamBase.h"
@@ -35,7 +38,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    * 						to high to enable the device.
    */
   StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                     StrHelper* strHelper, power::Switch_t powerSwitch);
+                     const char* jsonFileStr, StrHelper* strHelper, power::Switch_t powerSwitch);
   virtual ~StarTrackerHandler();
 
   ReturnValue_t initialize() override;
@@ -216,15 +219,29 @@ class StarTrackerHandler : public DeviceHandlerBase {
   // Loading firmware requires some time and the command will not trigger a reply when executed
   Countdown bootCountdown;
 
-#ifdef EGSE
+  struct JsonConfigs {
-  std::string paramJsonFile = "/home/pi/arcsec/json/flight-config.json";
+    Tracking tracking;
-#else
+    LogLevel logLevel;
-#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
+    LogSubscription logSubscription;
-  std::string paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
+    DebugCamera debugCamera;
-#else
+    Algo algo;
-  std::string paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
+    Validation validation;
-#endif
+    Matching matching;
-#endif
+    Lisa lisa;
+    Centroiding centroiding;
+    Camera camera;
+    ImageProcessor imageProcessor;
+    Mounting mounting;
+    Limits limits;
+    Subscription subscription;
+  };
+  JsonConfigs jcfgs;
+  Countdown jcfgCountdown = Countdown(250);
+  bool commandExecuted = false;
+  std::thread jsonCfgTask;
+  static void setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonFile);
+
+  std::string paramJsonFile;
 
   enum class NormalState { TEMPERATURE_REQUEST, SOLUTION_REQUEST };
 
@@ -262,7 +279,14 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   InternalState internalState = InternalState::IDLE;
 
-  enum class StartupState { IDLE, CHECK_PROGRAM, WAIT_CHECK_PROGRAM, BOOT_BOOTLOADER, DONE };
+  enum class StartupState {
+    IDLE,
+    CHECK_PROGRAM,
+    WAIT_CHECK_PROGRAM,
+    BOOT_BOOTLOADER,
+    WAIT_JCFG,
+    DONE
+  };
 
   StartupState startupState = StartupState::IDLE;
 

thirdparty/arcsec_star_tracker

@@ -1 +1 @@
-Subproject commit 93e93965e2c6405170b62c523dea1990db02d2ad
+Subproject commit 42907c36c58e7133d3d3cbefbf96c1a8e35b60b7