Merge remote-tracking branch 'origin/develop' into mueller/system-subsystems

bsp_q7s/core/CoreController.cpp

@@ -13,7 +13,6 @@
 #else
 #include "fsfw/osal/common/TcpTmTcServer.h"
 #endif
-
 #include <fcntl.h>
 #include <unistd.h>
 
@@ -21,12 +20,13 @@
 
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
+#include "bsp_q7s/xadc/Xadc.h"
 
 xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
 CoreController::CoreController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5), opDivider(5) {
+    : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5), opDivider(5), hkSet(this) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   try {
     result = initWatchdogFifo();
@@ -60,14 +60,23 @@ void CoreController::performControlOperation() {
   performWatchdogControlOperation();
   sdStateMachine();
   performMountedSdCardOperations();
+  readHkData();
 }
 
 ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                       LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(core::TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(core::PS_VOLTAGE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(core::PL_VOLTAGE, new PoolEntry<float>({0}));
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-LocalPoolDataSetBase *CoreController::getDataSetHandle(sid_t sid) { return nullptr; }
+LocalPoolDataSetBase *CoreController::getDataSetHandle(sid_t sid) {
+    if (sid.ownerSetId == core::HK_SET_ID) {
+        return &hkSet;
+    }
+    return nullptr;
+}
 
 ReturnValue_t CoreController::initialize() {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -104,6 +113,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
   setenv("PATH", updatedEnvPath.c_str(), true);
   updateProtInfo();
   initPrint();
+  ExtendedControllerBase::initializeAfterTaskCreation();
   return result;
 }
 
@@ -1645,3 +1655,37 @@ void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::C
   }
   rewriteRebootFile(rebootFile);
 }
+
+void CoreController::readHkData() {
+  ReturnValue_t result = RETURN_OK;
+  result = hkSet.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
+  if (result != RETURN_OK) {
+    return;
+  }
+  Xadc xadc;
+  result = xadc.getTemperature(hkSet.temperature.value);
+  if (result != RETURN_OK) {
+    hkSet.temperature.setValid(false);
+  } else {
+    hkSet.temperature.setValid(true);
+  }
+  result = xadc.getVccPint(hkSet.psVoltage.value);
+  if (result != RETURN_OK) {
+    hkSet.psVoltage.setValid(false);
+  } else {
+    hkSet.psVoltage.setValid(true);
+  }
+  result = xadc.getVccInt(hkSet.plVoltage.value);
+  if (result != RETURN_OK) {
+    hkSet.plVoltage.setValid(false);
+  } else {
+    hkSet.plVoltage.setValid(true);
+  }
+#if OBSW_PRINT_CORE_HK == 1
+  hkSet.printSet();
+#endif /* OBSW_PRINT_CORE_HK == 1 */
+  result = hkSet.commit(TIMEOUT_TYPE, MUTEX_TIMEOUT);
+  if (result != RETURN_OK) {
+    return;
+  }
+}

bsp_q7s/core/CoreController.h

@@ -9,6 +9,7 @@
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
+#include "CoreDefinitions.h"
 
 class Timer;
 class SdCardManager;
@@ -120,6 +121,8 @@ class CoreController : public ExtendedControllerBase {
   bool sdInitFinished() const;
 
  private:
+  static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
+  static constexpr uint32_t MUTEX_TIMEOUT = 20;
   // Designated value for rechecking FIFO open
   static constexpr int RETRY_FIFO_OPEN = -2;
   int watchdogFifoFd = 0;
@@ -181,6 +184,8 @@ class CoreController : public ExtendedControllerBase {
   std::array<bool, 4> protArray;
   PeriodicOperationDivider opDivider;
 
+  core::HkSet hkSet;
+
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
@@ -220,6 +225,7 @@ class CoreController : public ExtendedControllerBase {
   void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
   bool parseRebootFile(std::string path, RebootFile& file);
   void rewriteRebootFile(RebootFile file);
+  void readHkData();
 };
 
 #endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */

bsp_q7s/core/CoreDefinitions.h

@@ -0,0 +1,44 @@
+#ifndef BSP_Q7S_CORE_COREDEFINITIONS_H_
+#define BSP_Q7S_CORE_COREDEFINITIONS_H_
+
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+
+namespace core {
+
+static const uint8_t HK_SET_ENTRIES = 3;
+static const uint32_t HK_SET_ID = 5;
+
+enum PoolIds {
+    TEMPERATURE,
+    PS_VOLTAGE,
+    PL_VOLTAGE
+};
+
+/**
+ * @brief   Set storing OBC internal housekeeping data
+ */
+class HkSet : public StaticLocalDataSet<HK_SET_ENTRIES> {
+ public:
+
+  HkSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HK_SET_ID) {}
+
+  HkSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HK_SET_ID)) {}
+
+  // On-chip temperature
+  lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, PoolIds::TEMPERATURE, this);
+  // Processing system VCC
+  lp_var_t<float> psVoltage = lp_var_t<float>(sid.objectId, PoolIds::PS_VOLTAGE, this);
+  // Programmable logic VCC
+  lp_var_t<float> plVoltage = lp_var_t<float>(sid.objectId, PoolIds::PL_VOLTAGE, this);
+
+  void printSet() {
+    sif::info << "HkSet::printSet: On-chip temperature: " << this->temperature
+            << " °C" << std::endl;
+    sif::info << "HkSet::printSet: PS voltage: " << this->psVoltage << " mV" << std::endl;
+    sif::info << "HkSet::printSet: PL voltage: " << this->plVoltage << " mV" << std::endl;
+  }
+};
+
+}
+
+#endif /* BSP_Q7S_CORE_COREDEFINITIONS_H_ */