Merge pull request 'prep v4.0.1 patch' (#705) from prep_v4.0.1 into main

Reviewed-on: #705

CHANGELOG.md

@@ -16,7 +16,64 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
-# [v4.0.0] to be released
+# [v4.0.1] 2023-06-24
+
+## Fixed
+
+- `PusLiveDemux` packet demultiplexing bugfix where the demultiplexing did not work when there was
+  only one destination available.
+
+# [v4.0.0] 2023-06-22
+
+- `eive-tmtc` version v5.0.0
+- `q7s-package` version v3.1.1
+
+## Fixed
+
+- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
+- TCS fixes: Set temperature values to invalid value for MAX31865 RTD handler, SUS handler
+  and STR handler. Also set dataset to invakid for RTD handler.
+- Fixed H parameter in SUS converter from 1 mm to 2.5 mm.
+
+## Changed
+
+- Removed PTME busy/ready signals. Those were not used anyway because register reads are used now.
+- APB bus access busy checking is not done anymore as this is performed by the bus itself now.
+- Core controller will now announce version and image information event in addition to reboot
+  event in the `inititalize` function.
+- Core controller will now try to request and announce the firmware version in addition to the
+  OBSW version as well.
+- Added core controller action to read reboot mechansm information
+- GNSS reset pin will now only be asserted for 5 ms instead of 100 ms.
+
+## Added
+
+- Added PL I2C reset pin. It is not used/connected for now but could be used for FDIR procedures to
+  restore the PL I2C.
+- Core controller now announces firmware version as well when requesting a version info event
+
+# [v3.3.0] 2023-06-21
+
+Like v3.2.0 but without the custom FM changes related to VC0.
+
+# [v3.2.0] 2023-06-21
+
+## Fixed
+
+- Fix sun vector calculation
+- SUS total vector was not reset to being a zero vector during eclipse due to a wrong memcpy
+  length.
+
+## Changed
+
+- Reverted all changes related to VC0 handling to avoid FM bug possibly related to FPGA bug.
+
+# [v3.1.1] 2023-06-14
+
+## Fixed
+
+- TMP1075 bugfix where negative temperatures could not be measured because of a two's-complement
+  conversion bug.
 
 # [v3.1.0] 2023-06-14
 

CMakeLists.txt

@@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 3)
-set(OBSW_VERSION_MINOR 1)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_MAJOR 4)
+set(OBSW_VERSION_MINOR 0)
+set(OBSW_VERSION_REVISION 1)
 
 # set(CMAKE_VERBOSE TRUE)
 

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 295 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateEvents.h"
 
@@ -277,6 +277,7 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -847,6 +848,8 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 171 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateObjects.h"
 

bsp_q7s/boardconfig/busConf.h

@@ -23,6 +23,7 @@ static constexpr char UART_SCEX_DEV[] = "/dev/scex";
 static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio_pdec_regs";
 static constexpr char UIO_PTME[] = "/dev/uio_ptme";
 static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio_pdec_cfg_mem";
+static constexpr char UIO_SYS_ROM[] = "/dev/uio_sys_rom";
 static constexpr char UIO_PDEC_RAM[] = "/dev/uio_pdec_ram";
 static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
 static constexpr int MAP_ID_PTME_CONFIG = 3;
@@ -57,6 +58,7 @@ static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
 static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
 static constexpr char GNSS_SELECT[] = "gnss_mux_select";
 static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
+static constexpr char PL_I2C_ARESETN[] = "pl_i2c_aresetn";
 
 static constexpr char HEATER_0[] = "heater0";
 static constexpr char HEATER_1[] = "heater1";
@@ -82,14 +84,12 @@ static constexpr char EN_RW_4[] = "enable_rw_4";
 
 static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
 static constexpr char ENABLE_RADFET[] = "enable_radfet";
-static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
+
 static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
-static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
 static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
-static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
 static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
-static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
 static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
+
 static constexpr char PTME_RESETN[] = "ptme_resetn";
 
 static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";

bsp_q7s/core/CoreController.cpp

@@ -4,6 +4,7 @@
 #include <fsfw/filesystem/HasFileSystemIF.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 
 #include "commonConfig.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -22,6 +23,7 @@
 #include <algorithm>
 #include <filesystem>
 
+#include "bsp_q7s/boardconfig/busConf.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "bsp_q7s/xadc/Xadc.h"
@@ -169,6 +171,8 @@ ReturnValue_t CoreController::initialize() {
   sdStateMachine();
 
   triggerEvent(core::REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
+  announceCurrentImageInfo();
+  announceVersionInfo();
   EventManagerIF *eventManager =
       ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (eventManager == nullptr or eventQueue == nullptr) {
@@ -185,6 +189,14 @@ ReturnValue_t CoreController::initialize() {
   if (result != returnvalue::OK) {
     sif::warning << "Subscribing for GPS GPS_FIX_CHANGE event failed" << std::endl;
   }
+
+  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
+  result = sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
+  if (result != returnvalue::OK) {
+    // TODO: This might be a reason to switch to another image..
+    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
   return returnvalue::OK;
 }
 
@@ -210,19 +222,7 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
   using namespace core;
   switch (actionId) {
     case (ANNOUNCE_VERSION): {
-      uint32_t p1 = (common::OBSW_VERSION_MAJOR << 24) | (common::OBSW_VERSION_MINOR << 16) |
-                    (common::OBSW_VERSION_REVISION << 8);
-      uint32_t p2 = 0;
-      if (strcmp("", common::OBSW_VERSION_CST_GIT_SHA1) != 0) {
-        p1 |= 1;
-        auto shaAsStr = std::string(common::OBSW_VERSION_CST_GIT_SHA1);
-        size_t posDash = shaAsStr.find("-");
-        auto gitHash = shaAsStr.substr(posDash + 2, 4);
-        // Only copy first 4 letters of git hash
-        memcpy(&p2, gitHash.c_str(), 4);
-      }
-
-      triggerEvent(VERSION_INFO, p1, p2);
+      announceVersionInfo();
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (ANNOUNCE_BOOT_COUNTS): {
@@ -230,7 +230,7 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (ANNOUNCE_CURRENT_IMAGE): {
-      triggerEvent(CURRENT_IMAGE_INFO, CURRENT_CHIP, CURRENT_COPY);
+      announceCurrentImageInfo();
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (LIST_DIRECTORY_INTO_FILE): {
@@ -246,6 +246,9 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
         return result;
       }
       std::ostringstream oss("cp ", std::ostringstream::ate);
+      if (parser.isForceOptSet()) {
+        oss << "-f ";
+      }
       if (parser.isRecursiveOptSet()) {
         oss << "-r ";
       }
@@ -319,7 +322,6 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
         return HasActionsIF::INVALID_PARAMETERS;
       }
       std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
-      // Disable the reboot file mechanism
       parseRebootFile(path, rebootFile);
       if (data[0] == 0) {
         rebootFile.enabled = false;
@@ -332,6 +334,16 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       }
       return HasActionsIF::EXECUTION_FINISHED;
     }
+    case (READ_REBOOT_MECHANISM_INFO): {
+      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
+      parseRebootFile(path, rebootFile);
+      RebootMechanismPacket packet(rebootFile);
+      ReturnValue_t result = actionHelper.reportData(commandedBy, actionId, &packet);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
     case (RESET_REBOOT_COUNTERS): {
       if (size == 0) {
         resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
@@ -1998,7 +2010,6 @@ bool CoreController::parseRebootFile(std::string path, RebootFile &rf) {
 
 void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
   std::string path = currMntPrefix + REBOOT_FILE;
-  // Disable the reboot file mechanism
   parseRebootFile(path, rebootFile);
   if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
     rebootFile.img00Cnt = 0;
@@ -2405,6 +2416,33 @@ void CoreController::dirListingDumpHandler() {
   }
 }
 
+void CoreController::announceVersionInfo() {
+  using namespace core;
+  uint32_t p1 = (common::OBSW_VERSION_MAJOR << 24) | (common::OBSW_VERSION_MINOR << 16) |
+                (common::OBSW_VERSION_REVISION << 8);
+  uint32_t p2 = 0;
+  if (strcmp("", common::OBSW_VERSION_CST_GIT_SHA1) != 0) {
+    p1 |= 1;
+    auto shaAsStr = std::string(common::OBSW_VERSION_CST_GIT_SHA1);
+    size_t posDash = shaAsStr.find("-");
+    auto gitHash = shaAsStr.substr(posDash + 2, 4);
+    // Only copy first 4 letters of git hash
+    memcpy(&p2, gitHash.c_str(), 4);
+  }
+
+  triggerEvent(VERSION_INFO, p1, p2);
+  if (mappedSysRomAddr != nullptr) {
+    uint32_t p1Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr));
+    uint32_t p2Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr) + 1);
+    triggerEvent(FIRMWARE_INFO, p1Firmware, p2Firmware);
+  }
+}
+
+void CoreController::announceCurrentImageInfo() {
+  using namespace core;
+  triggerEvent(CURRENT_IMAGE_INFO, CURRENT_CHIP, CURRENT_COPY);
+}
+
 bool CoreController::isNumber(const std::string &s) {
   return !s.empty() && std::find_if(s.begin(), s.end(),
                                     [](unsigned char c) { return !std::isdigit(c); }) == s.end();

bsp_q7s/core/CoreController.h

@@ -6,6 +6,7 @@
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
 #include <mission/acs/archive/GPSDefinitions.h>
 #include <mission/utility/trace.h>
@@ -44,6 +45,61 @@ struct RebootFile {
   xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
+class RebootMechanismPacket : public SerialLinkedListAdapter<SerializeIF> {
+ public:
+  RebootMechanismPacket(RebootFile& rf) {
+    enabled = rf.enabled;
+    maxCount = rf.maxCount;
+    img00Count = rf.img00Cnt;
+    img01Count = rf.img01Cnt;
+    img10Count = rf.img10Cnt;
+    img11Count = rf.img11Cnt;
+    img00Lock = rf.img00Lock;
+    img01Lock = rf.img01Lock;
+    img10Lock = rf.img10Lock;
+    img11Lock = rf.img11Lock;
+    lastChip = static_cast<uint8_t>(rf.lastChip);
+    lastCopy = static_cast<uint8_t>(rf.lastCopy);
+    nextChip = static_cast<uint8_t>(rf.mechanismNextChip);
+    nextCopy = static_cast<uint8_t>(rf.mechanismNextCopy);
+    setLinks();
+  }
+
+ private:
+  void setLinks() {
+    setStart(&enabled);
+    enabled.setNext(&maxCount);
+    maxCount.setNext(&img00Count);
+    img00Count.setNext(&img01Count);
+    img01Count.setNext(&img10Count);
+    img10Count.setNext(&img11Count);
+    img11Count.setNext(&img00Lock);
+    img00Lock.setNext(&img01Lock);
+    img01Lock.setNext(&img10Lock);
+    img10Lock.setNext(&img11Lock);
+    img11Lock.setNext(&lastChip);
+    lastChip.setNext(&lastCopy);
+    lastCopy.setNext(&nextChip);
+    nextChip.setNext(&nextCopy);
+    setLast(&nextCopy);
+  }
+
+  SerializeElement<uint8_t> enabled = false;
+  SerializeElement<uint32_t> maxCount = 0;
+  SerializeElement<uint32_t> img00Count = 0;
+  SerializeElement<uint32_t> img01Count = 0;
+  SerializeElement<uint32_t> img10Count = 0;
+  SerializeElement<uint32_t> img11Count = 0;
+  SerializeElement<uint8_t> img00Lock = false;
+  SerializeElement<uint8_t> img01Lock = false;
+  SerializeElement<uint8_t> img10Lock = false;
+  SerializeElement<uint8_t> img11Lock = false;
+  SerializeElement<uint8_t> lastChip = 0;
+  SerializeElement<uint8_t> lastCopy = 0;
+  SerializeElement<uint8_t> nextChip = 0;
+  SerializeElement<uint8_t> nextCopy = 0;
+};
+
 class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
  public:
   enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
@@ -142,6 +198,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
 
   static constexpr bool BLOCKING_SD_INIT = false;
 
+  uint32_t* mappedSysRomAddr = nullptr;
   SdCardManager* sdcMan = nullptr;
   MessageQueueIF* eventQueue = nullptr;
 
@@ -287,6 +344,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   bool parseRebootFile(std::string path, RebootFile& file);
   void rewriteRebootFile(RebootFile file);
   void announceBootCounts();
+  void announceVersionInfo();
+  void announceCurrentImageInfo();
   void readHkData();
   void dirListingDumpHandler();
   bool isNumber(const std::string& s);

bsp_q7s/core/ObjectFactory.cpp

@@ -2,6 +2,7 @@
 
 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
+#include <fsfw/tasks/TaskFactory.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@@ -505,7 +506,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
   debugGps = true;
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 100;
+  RESET_ARGS_GNSS.waitPeriodMs = 5;
   auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                 enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@@ -730,20 +731,12 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
   GpiodRegularByLineName* gpio = nullptr;
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, "PAPB VC0");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, "PAPB VC0");
   gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, "PAPB VC1");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC1, "PAPB VC1");
   gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, "PAPB VC2");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, "PAPB VC2");
   gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, "PAPB VC3");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
@@ -752,18 +745,14 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
   // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-  VirtualChannelIF* vc1 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-  VirtualChannelIF* vc2 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc3 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
+  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
+  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
+  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
+  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
   // Creating ptme object and adding virtual channel interfaces
   Ptme* ptme = new Ptme(objects::PTME);
   ptme->addVcInterface(ccsds::VC0, vc0);
@@ -1025,3 +1014,19 @@ void ObjectFactory::createRadSensorChipSelect(LinuxLibgpioIF* gpioIF) {
   gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
   gpioChecker(gpioIF->addGpios(gpioCookieRadSensor), "RAD sensor");
 }
+
+void ObjectFactory::createPlI2cResetGpio(LinuxLibgpioIF* gpioIF) {
+  using namespace gpio;
+  if (gpioIF == nullptr) {
+    return;
+  }
+  GpioCookie* gpioI2cResetnCookie = new GpioCookie;
+  GpiodRegularByLineName* gpioI2cResetn = new GpiodRegularByLineName(
+      q7s::gpioNames::PL_I2C_ARESETN, "PL_I2C_ARESETN", Direction::OUT, Levels::HIGH);
+  gpioI2cResetnCookie->addGpio(gpioIds::PL_I2C_ARESETN, gpioI2cResetn);
+  gpioChecker(gpioIF->addGpios(gpioI2cResetnCookie), "PL I2C ARESETN");
+  // Reset I2C explicitely again.
+  gpioIF->pullLow(gpioIds::PL_I2C_ARESETN);
+  TaskFactory::delayTask(1);
+  gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
+}

bsp_q7s/core/ObjectFactory.h

@@ -78,6 +78,7 @@ ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);
+void createPlI2cResetGpio(LinuxLibgpioIF* gpioComIF);
 
 void testAcsBrdAss(AcsBoardAssembly* assAss);
 

bsp_q7s/em/emObjectFactory.cpp

@@ -47,6 +47,7 @@ void ObjectFactory::produce(void* args) {
   /* Adding gpios for chip select decoding to the gpioComIf */
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPlI2cResetGpio(gpioComIF);
 
   // Hardware is usually not connected to EM, so we need to create dummies which replace lower
   // level components.
@@ -83,21 +84,6 @@ void ObjectFactory::produce(void* args) {
 
   new CoreController(objects::CORE_CONTROLLER, enableHkSets);
 
-  // Regular FM code, does not work for EM if the hardware is not connected
-  // createPcduComponents(gpioComIF, &pwrSwitcher);
-  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
-  // createSyrlinksComponents(pwrSwitcher);
-  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
-  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  // createTmpComponents();
-  // createSolarArrayDeploymentComponents();
-  // createPayloadComponents(gpioComIF);
-  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-
-  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
-  //       and will cause xsc_boot_copy commands to always boot to 0 0
-  // createRadSensorComponent(gpioComIF);
-
 #if OBSW_ADD_ACS_BOARD == 1
   // Still initialize chip select to avoid SPI bus issues.
   createRadSensorChipSelect(gpioComIF);

bsp_q7s/fmObjectFactory.cpp

@@ -45,6 +45,7 @@ void ObjectFactory::produce(void* args) {
   /* Adding gpios for chip select decoding to the gpioComIf */
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPlI2cResetGpio(gpioComIF);
 
   new CoreController(objects::CORE_CONTROLLER, enableHkSets);
   createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);

common/config/devices/gpioIds.h

@@ -77,6 +77,8 @@ enum gpioId_t {
   CS_RAD_SENSOR,
   ENABLE_RADFET,
 
+  PL_I2C_ARESETN,
+
   PAPB_BUSY_N,
   PAPB_EMPTY,
 
@@ -93,15 +95,10 @@ enum gpioId_t {
   EN_RW_CS,
 
   SPI_MUX,
-
   VC0_PAPB_EMPTY,
-  VC0_PAPB_BUSY,
   VC1_PAPB_EMPTY,
-  VC1_PAPB_BUSY,
   VC2_PAPB_EMPTY,
-  VC2_PAPB_BUSY,
   VC3_PAPB_EMPTY,
-  VC3_PAPB_BUSY,
   PTME_RESETN,
 
   PDEC_RESET,

dummies/ImtqDummy.cpp

@@ -5,14 +5,19 @@
 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
                      power::Switch_t pwrSwitcher, bool enableHkSets)
     : DeviceHandlerBase(objectId, comif, comCookie),
-      setNoTorque(this),
-      setWithTorque(this),
       enableHkSets(enableHkSets),
+      statusSet(this),
+      dipoleSet(*this),
+      rawMtmNoTorque(this),
+      hkDatasetNoTorque(this),
+      rawMtmWithTorque(this),
+      hkDatasetWithTorque(this),
+      calMtmMeasurementSet(this),
       switcher(pwrSwitcher) {}
 
 ImtqDummy::~ImtqDummy() = default;
 
-void ImtqDummy::doStartUp() { setMode(MODE_NORMAL); }
+void ImtqDummy::doStartUp() { setMode(MODE_ON); }
 
 void ImtqDummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
 
@@ -79,17 +84,37 @@ ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataP
   localDataPoolMap.emplace(imtq::MCU_TEMPERATURE_WT, new PoolEntry<int16_t>({0}));
 
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(setNoTorque.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(setWithTorque.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(rawMtmWithTorque.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(calMtmMeasurementSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(statusSet.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(dipoleSet.getSid(), false, 10.0));
   return DeviceHandlerBase::initializeLocalDataPool(localDataPoolMap, poolManager);
 }
 
 LocalPoolDataSetBase *ImtqDummy::getDataSetHandle(sid_t sid) {
-  if (sid == setNoTorque.getSid()) {
-    return &setNoTorque;
-  } else if (sid == setWithTorque.getSid()) {
-    return &setWithTorque;
+  if (sid == hkDatasetNoTorque.getSid()) {
+    return &hkDatasetNoTorque;
+  } else if (sid == dipoleSet.getSid()) {
+    return &dipoleSet;
+  } else if (sid == statusSet.getSid()) {
+    return &statusSet;
+  } else if (sid == hkDatasetWithTorque.getSid()) {
+    return &hkDatasetWithTorque;
+  } else if (sid == rawMtmWithTorque.getSid()) {
+    return &rawMtmWithTorque;
+  } else if (sid == calMtmMeasurementSet.getSid()) {
+    return &calMtmMeasurementSet;
+  } else if (sid == rawMtmNoTorque.getSid()) {
+    return &rawMtmNoTorque;
   }
   return nullptr;
 }

dummies/ImtqDummy.h

@@ -18,11 +18,18 @@ class ImtqDummy : public DeviceHandlerBase {
   ~ImtqDummy() override;
 
  protected:
-  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
-  imtq::HkDatasetNoTorque setNoTorque;
-  imtq::HkDatasetWithTorque setWithTorque;
   bool enableHkSets;
 
+  imtq::StatusDataset statusSet;
+  imtq::DipoleActuationSet dipoleSet;
+  imtq::RawMtmMeasurementNoTorque rawMtmNoTorque;
+  imtq::HkDatasetNoTorque hkDatasetNoTorque;
+
+  imtq::RawMtmMeasurementWithTorque rawMtmWithTorque;
+  imtq::HkDatasetWithTorque hkDatasetWithTorque;
+
+  imtq::CalibratedMtmMeasurementSet calMtmMeasurementSet;
+
   PoolEntry<uint8_t> statusMode = PoolEntry<uint8_t>({0});
   PoolEntry<uint8_t> statusError = PoolEntry<uint8_t>({0});
   PoolEntry<uint8_t> statusConfig = PoolEntry<uint8_t>({0});
@@ -42,6 +49,8 @@ class ImtqDummy : public DeviceHandlerBase {
 
   power::Switch_t switcher = power::NO_SWITCH;
 
+  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/RwDummy.cpp

@@ -3,13 +3,24 @@
 #include <mission/acs/rwHelpers.h>
 
 RwDummy::RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+    : DeviceHandlerBase(objectId, comif, comCookie),
+
+      statusSet(this),
+      lastResetStatusSet(this),
+      tmDataset(this),
+      rwSpeedActuationSet(*this) {}
 
 RwDummy::~RwDummy() {}
 
-void RwDummy::doStartUp() { setMode(MODE_ON); }
+void RwDummy::doStartUp() {
+  statusSet.setReportingEnabled(true);
+  setMode(MODE_ON);
+}
 
-void RwDummy::doShutDown() { setMode(MODE_OFF); }
+void RwDummy::doShutDown() {
+  statusSet.setReportingEnabled(false);
+  setMode(MODE_OFF);
+}
 
 ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
@@ -74,5 +85,11 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
   localDataPoolMap.emplace(rws::SPI_BYTES_READ, new PoolEntry<uint32_t>({0}));
   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));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(tmDataset.getSid(), false, 30.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(lastResetStatusSet.getSid(), false, 30.0));
   return returnvalue::OK;
 }

dummies/RwDummy.h

@@ -2,6 +2,7 @@
 #define DUMMIES_RWDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/acs/rwHelpers.h>
 
 class RwDummy : public DeviceHandlerBase {
  public:
@@ -15,6 +16,11 @@ class RwDummy : public DeviceHandlerBase {
   virtual ~RwDummy();
 
  protected:
+  rws::StatusSet statusSet;
+  rws::LastResetSatus lastResetStatusSet;
+  rws::TmDataset tmDataset;
+  rws::RwSpeedActuationSet rwSpeedActuationSet;
+
   PoolEntry<int32_t> rwSpeed = PoolEntry<int32_t>({0});
   PoolEntry<uint16_t> rampTime = PoolEntry<uint16_t>({10});
 

generators/bsp_hosted_events.csv

@@ -271,6 +271,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14010;0x36ba;TRYING_I2C_RECOVERY;HIGH;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
+14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h

generators/bsp_q7s_events.csv

@@ -271,6 +271,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14010;0x36ba;TRYING_I2C_RECOVERY;HIGH;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
+14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 295 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateEvents.h"
 
@@ -277,6 +277,7 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -847,6 +848,8 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):

generators/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 175 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 295 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateEvents.h"
 
@@ -277,6 +277,7 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -847,6 +848,8 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 175 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateObjects.h"
 

linux/ipcore/PapbVcInterface.cpp

@@ -7,20 +7,16 @@
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId,
-                                 gpioId_t papbEmptyId, std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF),
-      papbBusyId(papbBusyId),
-      papbEmptyId(papbEmptyId),
-      uioFile(std::move(uioFile)),
-      mapNum(mapNum) {}
+PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
+                                 std::string uioFile, int mapNum)
+    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
 
 PapbVcInterface::~PapbVcInterface() {}
 
 ReturnValue_t PapbVcInterface::initialize() {
   UioMapper uioMapper(uioFile, mapNum);
   ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
-                                                   UioMapper::Permissions::WRITE_ONLY);
+                                                   UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -32,63 +28,16 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
   if (size < 4) {
     return returnvalue::FAILED;
   }
-  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
+  if (pollReadyForPacket()) {
     startPacketTransfer(ByteWidthCfg::ONE);
   } else {
     return DirectTmSinkIF::IS_BUSY;
   }
-  // TODO: This should work but does not.. :(
-  //  size_t idx = 0;
-  //  while (idx < size) {
-  //
-  //    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  //    if ((size - idx) < 4) {
-  //      *vcBaseReg = CONFIG_DATA_INPUT | (size - idx - 1);
-  //      usleep(1);
-  //    }
-  //    if (pollPapbBusySignal(2) == returnvalue::OK) {
-  //      //      vcBaseReg + DATA_REG_OFFSET + 3 = static_cast<uint8_t>(data + idx);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 2 = static_cast<uint8_t>(data + idx + 1);
-  //      //      vcBaseReg + DATA_REG_OFFSET + 1 = static_cast<uint8_t>(data + idx + 2);
-  //      //      vcBaseReg + DATA_REG_OFFSET = static_cast<uint8_t>(data + idx + 3);
-  //
-  //      // std::memcpy((vcBaseReg + DATA_REG_OFFSET), data + idx , nextWriteSize);
-  //      *(vcBaseReg + DATA_REG_OFFSET) = *reinterpret_cast<const uint32_t*>(data + idx);
-  //      //uint8_t* byteReg = reinterpret_cast<uint8_t*>(vcBaseReg + DATA_REG_OFFSET);
-  //
-  //      //byteReg[0] = data[idx];
-  //      //byteReg[1] = data[idx];
-  //    } else {
-  //      abortPacketTransfer();
-  //      return returnvalue::FAILED;
-  //    }
-  //    // TODO: Change this after the bugfix. Right now, the PAPB ignores the content of the byte
-  //    // width configuration.5
-  //    // It's okay to increment by a larger amount for the last segment here, loop will be over
-  //    // in any case.
-  //    idx += 4;
-  //  }
   for (size_t idx = 0; idx < size; idx++) {
-    // This delay is super-important, DO NOT REMOVE!
-    // Polling the GPIO or the config register too often messes up the scheduler.
-    // TODO: Maybe this should not be done like this. It would be better if there was a custom
-    // FPGA module which can accept packets and then takes care of dumping that packet into
-    // the PTME. DMA would be an ideal solution for this.
-    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-      *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
-    } else {
-      abortPacketTransfer();
-      return returnvalue::FAILED;
-    }
-  }
-  nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
-    completePacketTransfer();
-  } else {
-    abortPacketTransfer();
-    return returnvalue::FAILED;
+    // if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
   }
+  completePacketTransfer();
   return returnvalue::OK;
 }
 
@@ -98,60 +47,33 @@ void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
 
 void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
 
-ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
-                                                      bool checkReadyState) const {
-  uint32_t busyIdx = 0;
-  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
-
-  while (true) {
-    // Check if PAPB interface is ready to receive data. Use the configuration register for this.
-    // Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
-    uint32_t reg = *vcBaseReg;
-    bool busy = (reg >> 5) & 0b1;
-    bool ready = (reg >> 6) & 0b1;
-    if (not busy) {
-      return returnvalue::OK;
-    }
-    if (checkReadyState and not ready) {
-      return PAPB_BUSY;
-    }
-
-    busyIdx++;
-    if (busyIdx >= maxPollRetries) {
-      return PAPB_BUSY;
-    }
-
-    // Ignore signal handling here for now.
-    nanosleep(&nextDelay, &remDelay);
-    // Adaptive delay.
-    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
-      nextDelay.tv_nsec *= 2;
-    }
-  }
-  return returnvalue::OK;
+bool PapbVcInterface::pollReadyForPacket() const {
+  //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
+  //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
+  uint32_t reg = *vcBaseReg;
+  // bool busy = (reg >> 5) & 0b1;
+  return (reg >> 6) & 0b1;
 }
 
-void PapbVcInterface::isVcInterfaceBufferEmpty() {
+bool PapbVcInterface::isVcInterfaceBufferEmpty() {
   ReturnValue_t result = returnvalue::OK;
   gpio::Levels papbEmptyState = gpio::Levels::HIGH;
 
   result = gpioComIF->readGpio(papbEmptyId, papbEmptyState);
 
   if (result != returnvalue::OK) {
-    sif::warning << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
-                 << std::endl;
-    return;
+    sif::error << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
+               << std::endl;
+    return true;
   }
 
   if (papbEmptyState == gpio::Levels::HIGH) {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is empty" << std::endl;
-  } else {
-    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is not empty" << std::endl;
+    return true;
   }
-  return;
+  return false;
 }
 
-bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }
+bool PapbVcInterface::isBusy() const { return not pollReadyForPacket(); }
 
 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }
 

linux/ipcore/PapbVcInterface.h

@@ -30,8 +30,7 @@ class PapbVcInterface : public VirtualChannelIF {
    * @param uioFile       UIO file providing access to the PAPB bus
    * @param mapNum        Map number of UIO map associated with this virtual channel
    */
-  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId, gpioId_t papbEmptyId,
-                  std::string uioFile, int mapNum);
+  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum);
   virtual ~PapbVcInterface();
 
   bool isBusy() const override;
@@ -83,9 +82,6 @@ class PapbVcInterface : public VirtualChannelIF {
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
-
-  /** Pulled to low when virtual channel not ready to receive data */
-  gpioId_t papbBusyId = gpio::NO_GPIO;
   /** High when external buffer memory of virtual channel is empty */
   gpioId_t papbEmptyId = gpio::NO_GPIO;
 
@@ -120,13 +116,13 @@ class PapbVcInterface : public VirtualChannelIF {
    *
    * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
    */
-  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;
+  inline bool pollReadyForPacket() const;
 
   /**
    * @brief   This function can be used for debugging to check whether there are packets in
    *          the packet buffer of the virtual channel or not.
    */
-  void isVcInterfaceBufferEmpty();
+  bool isVcInterfaceBufferEmpty();
 
   /**
    * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)

mission/acs/SusHandler.cpp

@@ -30,6 +30,7 @@ void SusHandler::doStartUp() {
 void SusHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
     PoolReadGuard pg(&dataset);
+    dataset.tempC = thermal::INVALID_TEMPERATURE;
     dataset.setValidity(false, true);
     internalState = InternalState::SHUTDOWN;
     commandExecuted = false;

mission/acs/str/StarTrackerHandler.cpp

@@ -18,6 +18,7 @@ extern "C" {
 
 #include "OBSWConfig.h"
 #include "eive/definitions.h"
+#include "fsfw/thermal/tcsDefinitions.h"
 
 std::atomic_bool JCFG_DONE(false);
 
@@ -106,11 +107,14 @@ void StarTrackerHandler::doShutDown() {
     solutionSet.caliQx.value = 0.0;
     solutionSet.caliQy.value = 0.0;
     solutionSet.caliQz.value = 0.0;
-    solutionSet.isTrustWorthy = 0;
+    solutionSet.isTrustWorthy.value = 0;
     solutionSet.setValidity(false, true);
   }
   {
     PoolReadGuard pg(&temperatureSet);
+    temperatureSet.fpgaTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.cmosTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.mcuTemperature = thermal::INVALID_TEMPERATURE;
     temperatureSet.setValidity(false, true);
   }
   reinitNextSetParam = false;

mission/cfdp/CfdpHandler.cpp

@@ -93,7 +93,8 @@ ReturnValue_t CfdpHandler::handleCfdpPacket(TmTcMessage& msg) {
       return INVALID_PDU_FORMAT;
     }
     if (not FileDirectiveReader::checkFileDirective(pduDataField[0])) {
-      sif::error << "CfdpHandler: Invalid PDU directive field " << pduDataField[0] << std::endl;
+      sif::error << "CfdpHandler: Invalid PDU directive field " << static_cast<int>(pduDataField[0])
+                 << std::endl;
       return INVALID_DIRECTIVE_FIELD;
     }
     auto directive = static_cast<FileDirective>(pduDataField[0]);

mission/com/PersistentLogTmStoreTask.cpp

@@ -42,13 +42,7 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
     if (not someonesBusy) {
       TaskFactory::delayTask(100);
     } else if (vcBusyDuringDump) {
-      // TODO: Might not be necessary
-      sif::debug << "VC busy, delaying" << std::endl;
       TaskFactory::delayTask(10);
-    } else {
-      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
-      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
-      TaskFactory::delayTask(2);
     }
   }
 }

mission/com/PersistentSingleTmStoreTask.cpp

@@ -24,13 +24,7 @@ ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
     if (not busy) {
       TaskFactory::delayTask(100);
     } else if (dumpContext.vcBusyDuringDump) {
-      sif::debug << "VC busy, delaying" << std::endl;
-      // TODO: Might not be necessary
       TaskFactory::delayTask(10);
-    } else {
-      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
-      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
-      TaskFactory::delayTask(2);
     }
   }
 }

mission/controller/acs/AcsParameters.cpp

@@ -221,6 +221,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0x23:
           parameterWrapper->setMatrix(susHandlingParameters.sus11coeffBeta);
           break;
+        case 0x24:
+          parameterWrapper->set(susHandlingParameters.susBrightnessThreshold);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }

mission/controller/acs/AcsParameters.h

@@ -766,6 +766,7 @@ class AcsParameters : public HasParametersIF {
         {116.975421945286, -5.53022680362263, -5.61081660666997, 0.109754904982136,
          0.167666815691513, 0.163137400730063, -0.000609874123906977, -0.00205336098697513,
          -0.000889232196185857, -0.00168429567131815}};
+    float susBrightnessThreshold = 0.7;
   } susHandlingParameters;
 
   struct GyrHandlingParameters {

mission/controller/acs/SensorProcessing.cpp

@@ -30,10 +30,7 @@ void SensorProcessing::processMgm(const float *mgm0Value, bool mgm0valid, const
   // ------------------------------------------------
   double magIgrfModel[3] = {0.0, 0.0, 0.0};
   if (gpsValid) {
-    // Should be existing class object which will be called and modified here.
     Igrf13Model igrf13;
-    // So the line above should not be done here. Update: Can be done here as long updated coffs
-    //		stored in acsParameters ?
     igrf13.schmidtNormalization();
     igrf13.updateCoeffGH(timeOfMgmMeasurement);
     // maybe put a condition here, to only update after a full day, this
@@ -45,14 +42,13 @@ void SensorProcessing::processMgm(const float *mgm0Value, bool mgm0valid, const
     {
       PoolReadGuard pg(mgmDataProcessed);
       if (pg.getReadResult() == returnvalue::OK) {
-        float zeroVec[3] = {0.0, 0.0, 0.0};
-        std::memcpy(mgmDataProcessed->mgm0vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgm1vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgm2vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgm3vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgm4vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgmVecTot.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(mgmDataProcessed->mgmVecTotDerivative.value, zeroVec, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgm0vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgm1vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgm2vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgm3vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgm4vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(mgmDataProcessed->mgmVecTot.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(mgmDataProcessed->mgmVecTotDerivative.value, ZERO_VEC_D, 3 * sizeof(double));
         mgmDataProcessed->setValidity(false, true);
         std::memcpy(mgmDataProcessed->magIgrfModel.value, magIgrfModel, 3 * sizeof(double));
         mgmDataProcessed->magIgrfModel.setValid(gpsValid);
@@ -210,63 +206,68 @@ void SensorProcessing::processSus(
   sunIjkModel[0] = cos(eclipticLongitude);
   sunIjkModel[1] = sin(eclipticLongitude) * cos(epsilon);
   sunIjkModel[2] = sin(eclipticLongitude) * sin(epsilon);
+
+  uint64_t susBrightness[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   if (sus0valid) {
-    sus0valid = susConverter.checkSunSensorData(sus0Value);
+    susBrightness[0] = susConverter.checkSunSensorData(sus0Value);
   }
   if (sus1valid) {
-    sus1valid = susConverter.checkSunSensorData(sus1Value);
+    susBrightness[1] = susConverter.checkSunSensorData(sus1Value);
   }
   if (sus2valid) {
-    sus2valid = susConverter.checkSunSensorData(sus2Value);
+    susBrightness[2] = susConverter.checkSunSensorData(sus2Value);
   }
   if (sus3valid) {
-    sus3valid = susConverter.checkSunSensorData(sus3Value);
+    susBrightness[3] = susConverter.checkSunSensorData(sus3Value);
   }
   if (sus4valid) {
-    sus4valid = susConverter.checkSunSensorData(sus4Value);
+    susBrightness[4] = susConverter.checkSunSensorData(sus4Value);
   }
   if (sus5valid) {
-    sus5valid = susConverter.checkSunSensorData(sus5Value);
+    susBrightness[5] = susConverter.checkSunSensorData(sus5Value);
   }
   if (sus6valid) {
-    sus6valid = susConverter.checkSunSensorData(sus6Value);
+    susBrightness[6] = susConverter.checkSunSensorData(sus6Value);
   }
   if (sus7valid) {
-    sus7valid = susConverter.checkSunSensorData(sus7Value);
+    susBrightness[7] = susConverter.checkSunSensorData(sus7Value);
   }
   if (sus8valid) {
-    sus8valid = susConverter.checkSunSensorData(sus8Value);
+    susBrightness[8] = susConverter.checkSunSensorData(sus8Value);
   }
   if (sus9valid) {
-    sus9valid = susConverter.checkSunSensorData(sus9Value);
+    susBrightness[9] = susConverter.checkSunSensorData(sus9Value);
   }
   if (sus10valid) {
-    sus10valid = susConverter.checkSunSensorData(sus10Value);
+    susBrightness[10] = susConverter.checkSunSensorData(sus10Value);
   }
   if (sus11valid) {
-    sus11valid = susConverter.checkSunSensorData(sus11Value);
+    susBrightness[11] = susConverter.checkSunSensorData(sus11Value);
   }
 
-  if (!sus0valid && !sus1valid && !sus2valid && !sus3valid && !sus4valid && !sus5valid &&
-      !sus6valid && !sus7valid && !sus8valid && !sus9valid && !sus10valid && !sus11valid) {
+  bool susValid[12] = {sus0valid, sus1valid, sus2valid, sus3valid, sus4valid,  sus5valid,
+                       sus6valid, sus7valid, sus8valid, sus9valid, sus10valid, sus11valid};
+  bool allInvalid =
+      susConverter.checkValidity(susValid, susBrightness, susParameters->susBrightnessThreshold);
+
+  if (allInvalid) {
     {
       PoolReadGuard pg(susDataProcessed);
       if (pg.getReadResult() == returnvalue::OK) {
-        float zeroVec[3] = {0.0, 0.0, 0.0};
-        std::memcpy(susDataProcessed->sus0vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus1vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus2vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus3vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus4vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus5vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus6vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus7vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus8vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus9vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus10vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->sus11vec.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->susVecTot.value, zeroVec, 3 * sizeof(float));
-        std::memcpy(susDataProcessed->susVecTotDerivative.value, zeroVec, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus0vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus1vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus2vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus3vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus4vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus5vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus6vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus7vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus8vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus9vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus10vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->sus11vec.value, ZERO_VEC_F, 3 * sizeof(float));
+        std::memcpy(susDataProcessed->susVecTot.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(susDataProcessed->susVecTotDerivative.value, ZERO_VEC_D, 3 * sizeof(double));
         susDataProcessed->setValidity(false, true);
         std::memcpy(susDataProcessed->sunIjkModel.value, sunIjkModel, 3 * sizeof(double));
         susDataProcessed->sunIjkModel.setValid(true);
@@ -274,118 +275,78 @@ void SensorProcessing::processSus(
     }
     return;
   }
-  // WARNING: NOT TRANSFORMED IN BODY FRAME YET
-  // Transformation into Geomtry Frame
-  float sus0VecBody[3] = {0, 0, 0}, sus1VecBody[3] = {0, 0, 0}, sus2VecBody[3] = {0, 0, 0},
-        sus3VecBody[3] = {0, 0, 0}, sus4VecBody[3] = {0, 0, 0}, sus5VecBody[3] = {0, 0, 0},
-        sus6VecBody[3] = {0, 0, 0}, sus7VecBody[3] = {0, 0, 0}, sus8VecBody[3] = {0, 0, 0},
-        sus9VecBody[3] = {0, 0, 0}, sus10VecBody[3] = {0, 0, 0}, sus11VecBody[3] = {0, 0, 0};
 
-  if (sus0valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus0orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus0Value, susParameters->sus0coeffAlpha,
-                                             susParameters->sus0coeffBeta),
-        sus0VecBody, 3, 3, 1);
-  }
-  if (sus1valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus1orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus1Value, susParameters->sus1coeffAlpha,
-                                             susParameters->sus1coeffBeta),
-        sus1VecBody, 3, 3, 1);
-  }
-  if (sus2valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus2orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus2Value, susParameters->sus2coeffAlpha,
-                                             susParameters->sus2coeffBeta),
-        sus2VecBody, 3, 3, 1);
-  }
-  if (sus3valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus3orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus3Value, susParameters->sus3coeffAlpha,
-                                             susParameters->sus3coeffBeta),
-        sus3VecBody, 3, 3, 1);
-  }
-  if (sus4valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus4orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus4Value, susParameters->sus4coeffAlpha,
-                                             susParameters->sus4coeffBeta),
-        sus4VecBody, 3, 3, 1);
-  }
-  if (sus5valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus5orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus5Value, susParameters->sus5coeffAlpha,
-                                             susParameters->sus5coeffBeta),
-        sus5VecBody, 3, 3, 1);
-  }
-  if (sus6valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus6orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus6Value, susParameters->sus6coeffAlpha,
-                                             susParameters->sus6coeffBeta),
-        sus6VecBody, 3, 3, 1);
-  }
-  if (sus7valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus7orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus7Value, susParameters->sus7coeffAlpha,
-                                             susParameters->sus7coeffBeta),
-        sus7VecBody, 3, 3, 1);
-  }
-  if (sus8valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus8orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus8Value, susParameters->sus8coeffAlpha,
-                                             susParameters->sus8coeffBeta),
-        sus8VecBody, 3, 3, 1);
-  }
-  if (sus9valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus9orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus9Value, susParameters->sus9coeffAlpha,
-                                             susParameters->sus9coeffBeta),
-        sus9VecBody, 3, 3, 1);
-  }
-  if (sus10valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus10orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus10Value, susParameters->sus10coeffAlpha,
-                                             susParameters->sus10coeffBeta),
-        sus10VecBody, 3, 3, 1);
-  }
-  if (sus11valid) {
-    MatrixOperations<float>::multiply(
-        susParameters->sus11orientationMatrix[0],
-        susConverter.getSunVectorSensorFrame(sus11Value, susParameters->sus11coeffAlpha,
-                                             susParameters->sus11coeffBeta),
-        sus11VecBody, 3, 3, 1);
-  }
+  float susVecSensor[12][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+                               {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  float susVecBody[12][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+                             {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
 
-  /* ------ Mean Value: susDirEst ------ */
-  bool validIds[12] = {sus0valid, sus1valid, sus2valid, sus3valid, sus4valid,  sus5valid,
-                       sus6valid, sus7valid, sus8valid, sus9valid, sus10valid, sus11valid};
-  float susVecBody[3][12] = {{sus0VecBody[0], sus1VecBody[0], sus2VecBody[0], sus3VecBody[0],
-                              sus4VecBody[0], sus5VecBody[0], sus6VecBody[0], sus7VecBody[0],
-                              sus8VecBody[0], sus9VecBody[0], sus10VecBody[0], sus11VecBody[0]},
-                             {sus0VecBody[1], sus1VecBody[1], sus2VecBody[1], sus3VecBody[1],
-                              sus4VecBody[1], sus5VecBody[1], sus6VecBody[1], sus7VecBody[1],
-                              sus8VecBody[1], sus9VecBody[1], sus10VecBody[1], sus11VecBody[1]},
-                             {sus0VecBody[2], sus1VecBody[2], sus2VecBody[2], sus3VecBody[2],
-                              sus4VecBody[2], sus5VecBody[2], sus6VecBody[2], sus7VecBody[2],
-                              sus8VecBody[2], sus9VecBody[2], sus10VecBody[2], sus11VecBody[2]}};
+  if (susValid[0]) {
+    susConverter.calculateSunVector(susVecSensor[0], sus0Value);
+    MatrixOperations<float>::multiply(susParameters->sus0orientationMatrix[0], susVecSensor[0],
+                                      susVecBody[0], 3, 3, 1);
+  }
+  if (susValid[1]) {
+    susConverter.calculateSunVector(susVecSensor[1], sus1Value);
+    MatrixOperations<float>::multiply(susParameters->sus1orientationMatrix[0], susVecSensor[1],
+                                      susVecBody[1], 3, 3, 1);
+  }
+  if (susValid[2]) {
+    susConverter.calculateSunVector(susVecSensor[2], sus2Value);
+    MatrixOperations<float>::multiply(susParameters->sus2orientationMatrix[0], susVecSensor[2],
+                                      susVecBody[2], 3, 3, 1);
+  }
+  if (susValid[3]) {
+    susConverter.calculateSunVector(susVecSensor[3], sus3Value);
+    MatrixOperations<float>::multiply(susParameters->sus3orientationMatrix[0], susVecSensor[3],
+                                      susVecBody[3], 3, 3, 1);
+  }
+  if (susValid[4]) {
+    susConverter.calculateSunVector(susVecSensor[4], sus4Value);
+    MatrixOperations<float>::multiply(susParameters->sus4orientationMatrix[0], susVecSensor[4],
+                                      susVecBody[4], 3, 3, 1);
+  }
+  if (susValid[5]) {
+    susConverter.calculateSunVector(susVecSensor[5], sus5Value);
+    MatrixOperations<float>::multiply(susParameters->sus5orientationMatrix[0], susVecSensor[5],
+                                      susVecBody[5], 3, 3, 1);
+  }
+  if (susValid[6]) {
+    susConverter.calculateSunVector(susVecSensor[6], sus6Value);
+    MatrixOperations<float>::multiply(susParameters->sus6orientationMatrix[0], susVecSensor[6],
+                                      susVecBody[6], 3, 3, 1);
+  }
+  if (susValid[7]) {
+    susConverter.calculateSunVector(susVecSensor[7], sus7Value);
+    MatrixOperations<float>::multiply(susParameters->sus7orientationMatrix[0], susVecSensor[7],
+                                      susVecBody[7], 3, 3, 1);
+  }
+  if (susValid[8]) {
+    susConverter.calculateSunVector(susVecSensor[8], sus8Value);
+    MatrixOperations<float>::multiply(susParameters->sus8orientationMatrix[0], susVecSensor[8],
+                                      susVecBody[8], 3, 3, 1);
+  }
+  if (susValid[9]) {
+    susConverter.calculateSunVector(susVecSensor[9], sus9Value);
+    MatrixOperations<float>::multiply(susParameters->sus9orientationMatrix[0], susVecSensor[9],
+                                      susVecBody[9], 3, 3, 1);
+  }
+  if (susValid[10]) {
+    susConverter.calculateSunVector(susVecSensor[10], sus10Value);
+    MatrixOperations<float>::multiply(susParameters->sus10orientationMatrix[0], susVecSensor[10],
+                                      susVecBody[10], 3, 3, 1);
+  }
+  if (susValid[11]) {
+    susConverter.calculateSunVector(susVecSensor[11], sus11Value);
+    MatrixOperations<float>::multiply(susParameters->sus11orientationMatrix[0], susVecSensor[11],
+                                      susVecBody[11], 3, 3, 1);
+  }
 
   double susMeanValue[3] = {0, 0, 0};
   for (uint8_t i = 0; i < 12; i++) {
-    if (validIds[i]) {
-      susMeanValue[0] += susVecBody[0][i];
-      susMeanValue[1] += susVecBody[1][i];
-      susMeanValue[2] += susVecBody[2][i];
-    }
+    susMeanValue[0] += susVecBody[i][0];
+    susMeanValue[1] += susVecBody[i][1];
+    susMeanValue[2] += susVecBody[i][2];
   }
   double susVecTot[3] = {0.0, 0.0, 0.0};
   VectorOperations<double>::normalize(susMeanValue, susVecTot, 3);
@@ -406,29 +367,29 @@ void SensorProcessing::processSus(
   {
     PoolReadGuard pg(susDataProcessed);
     if (pg.getReadResult() == returnvalue::OK) {
-      std::memcpy(susDataProcessed->sus0vec.value, sus0VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus0vec.value, susVecBody[0], 3 * sizeof(float));
       susDataProcessed->sus0vec.setValid(sus0valid);
-      std::memcpy(susDataProcessed->sus1vec.value, sus1VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus1vec.value, susVecBody[1], 3 * sizeof(float));
       susDataProcessed->sus1vec.setValid(sus1valid);
-      std::memcpy(susDataProcessed->sus2vec.value, sus2VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus2vec.value, susVecBody[2], 3 * sizeof(float));
       susDataProcessed->sus2vec.setValid(sus2valid);
-      std::memcpy(susDataProcessed->sus3vec.value, sus3VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus3vec.value, susVecBody[3], 3 * sizeof(float));
       susDataProcessed->sus3vec.setValid(sus3valid);
-      std::memcpy(susDataProcessed->sus4vec.value, sus4VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus4vec.value, susVecBody[4], 3 * sizeof(float));
       susDataProcessed->sus4vec.setValid(sus4valid);
-      std::memcpy(susDataProcessed->sus5vec.value, sus5VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus5vec.value, susVecBody[5], 3 * sizeof(float));
       susDataProcessed->sus5vec.setValid(sus5valid);
-      std::memcpy(susDataProcessed->sus6vec.value, sus6VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus6vec.value, susVecBody[6], 3 * sizeof(float));
       susDataProcessed->sus6vec.setValid(sus6valid);
-      std::memcpy(susDataProcessed->sus7vec.value, sus7VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus7vec.value, susVecBody[7], 3 * sizeof(float));
       susDataProcessed->sus7vec.setValid(sus7valid);
-      std::memcpy(susDataProcessed->sus8vec.value, sus8VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus8vec.value, susVecBody[8], 3 * sizeof(float));
       susDataProcessed->sus8vec.setValid(sus8valid);
-      std::memcpy(susDataProcessed->sus9vec.value, sus9VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus9vec.value, susVecBody[9], 3 * sizeof(float));
       susDataProcessed->sus9vec.setValid(sus9valid);
-      std::memcpy(susDataProcessed->sus10vec.value, sus10VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus10vec.value, susVecBody[10], 3 * sizeof(float));
       susDataProcessed->sus10vec.setValid(sus10valid);
-      std::memcpy(susDataProcessed->sus11vec.value, sus11VecBody, 3 * sizeof(float));
+      std::memcpy(susDataProcessed->sus11vec.value, susVecBody[11], 3 * sizeof(float));
       susDataProcessed->sus11vec.setValid(sus11valid);
       std::memcpy(susDataProcessed->susVecTot.value, susVecTot, 3 * sizeof(double));
       susDataProcessed->susVecTot.setValid(true);
@@ -459,12 +420,11 @@ void SensorProcessing::processGyr(
     {
       PoolReadGuard pg(gyrDataProcessed);
       if (pg.getReadResult() == returnvalue::OK) {
-        double zeroVector[3] = {0.0, 0.0, 0.0};
-        std::memcpy(gyrDataProcessed->gyr0vec.value, zeroVector, 3 * sizeof(double));
-        std::memcpy(gyrDataProcessed->gyr1vec.value, zeroVector, 3 * sizeof(double));
-        std::memcpy(gyrDataProcessed->gyr2vec.value, zeroVector, 3 * sizeof(double));
-        std::memcpy(gyrDataProcessed->gyr3vec.value, zeroVector, 3 * sizeof(double));
-        std::memcpy(gyrDataProcessed->gyrVecTot.value, zeroVector, 3 * sizeof(double));
+        std::memcpy(gyrDataProcessed->gyr0vec.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(gyrDataProcessed->gyr1vec.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(gyrDataProcessed->gyr2vec.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(gyrDataProcessed->gyr3vec.value, ZERO_VEC_D, 3 * sizeof(double));
+        std::memcpy(gyrDataProcessed->gyrVecTot.value, ZERO_VEC_D, 3 * sizeof(double));
         gyrDataProcessed->setValidity(false, true);
       }
     }

mission/controller/acs/SensorProcessing.h

@@ -23,6 +23,9 @@ class SensorProcessing {
                acsctrl::GpsDataProcessed *gpsDataProcessed,
                const AcsParameters *acsParameters);  // Will call protected functions
  private:
+  static constexpr float ZERO_VEC_F[3] = {0, 0, 0};
+  static constexpr double ZERO_VEC_D[3] = {0, 0, 0};
+
  protected:
   // short description needed for every function
   void processMgm(const float *mgm0Value, bool mgm0valid, const float *mgm1Value, bool mgm1valid,

mission/controller/acs/SusConverter.cpp

@@ -1,121 +1,64 @@
 #include "SusConverter.h"
 
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/datapoollocal/LocalPoolVector.h>
-#include <fsfw/globalfunctions/math/VectorOperations.h>
 #include <math.h>
 
-#include <iostream>
-
-bool SusConverter::checkSunSensorData(const uint16_t susChannel[6]) {
-  if (susChannel[0] <= susChannelValueCheckLow || susChannel[0] > susChannelValueCheckHigh ||
+uint64_t SusConverter::checkSunSensorData(const uint16_t susChannel[6]) {
+  if (susChannel[0] <= SUS_CHANNEL_VALUE_LOW || susChannel[0] > SUS_CHANNEL_VALUE_HIGH ||
       susChannel[0] > susChannel[GNDREF]) {
-    return false;
+    return 0;
   }
-  if (susChannel[1] <= susChannelValueCheckLow || susChannel[1] > susChannelValueCheckHigh ||
+  if (susChannel[1] <= SUS_CHANNEL_VALUE_LOW || susChannel[1] > SUS_CHANNEL_VALUE_HIGH ||
       susChannel[1] > susChannel[GNDREF]) {
-    return false;
+    return 0;
   };
-  if (susChannel[2] <= susChannelValueCheckLow || susChannel[2] > susChannelValueCheckHigh ||
+  if (susChannel[2] <= SUS_CHANNEL_VALUE_LOW || susChannel[2] > SUS_CHANNEL_VALUE_HIGH ||
       susChannel[2] > susChannel[GNDREF]) {
-    return false;
+    return 0;
   };
-  if (susChannel[3] <= susChannelValueCheckLow || susChannel[3] > susChannelValueCheckHigh ||
+  if (susChannel[3] <= SUS_CHANNEL_VALUE_LOW || susChannel[3] > SUS_CHANNEL_VALUE_HIGH ||
       susChannel[3] > susChannel[GNDREF]) {
-    return false;
+    return 0;
   };
 
-  susChannelValueSum =
+  uint64_t susChannelValueSum =
       4 * susChannel[GNDREF] - (susChannel[0] + susChannel[1] + susChannel[2] + susChannel[3]);
-  if ((susChannelValueSum < susChannelValueSumHigh) &&
-      (susChannelValueSum > susChannelValueSumLow)) {
-    return false;
+  if (susChannelValueSum < SUS_ALBEDO_CHECK) {
+    return 0;
   };
-  return true;
+  return susChannelValueSum;
 }
 
-void SusConverter::calcAngle(const uint16_t susChannel[6]) {
-  float xout, yout;
-  float s = 0.03;  // s=[mm] gap between diodes
-  uint8_t d = 5;   // d=[mm] edge length of the quadratic aperture
-  uint8_t h = 1;   // h=[mm] distance between diodes and aperture
-  int ch0, ch1, ch2, ch3;
+bool SusConverter::checkValidity(bool* susValid, const uint64_t brightness[12],
+                                 const float threshold) {
+  uint8_t maxBrightness = 0;
+  VectorOperations<uint64_t>::maxValue(brightness, 12, &maxBrightness);
+  if (brightness[maxBrightness] == 0) {
+    return true;
+  }
+  for (uint8_t idx = 0; idx < 12; idx++) {
+    if ((idx != maxBrightness) and (brightness[idx] < threshold * brightness[maxBrightness])) {
+      susValid[idx] = false;
+      continue;
+    }
+    susValid[idx] = true;
+  }
+  return false;
+}
+
+void SusConverter::calculateSunVector(float* sunVectorSensorFrame, const uint16_t susChannel[6]) {
   // Substract measurement values from GNDREF zero current threshold
-  ch0 = susChannel[GNDREF] - susChannel[0];
-  ch1 = susChannel[GNDREF] - susChannel[1];
-  ch2 = susChannel[GNDREF] - susChannel[2];
-  ch3 = susChannel[GNDREF] - susChannel[3];
+  float ch0 = susChannel[GNDREF] - susChannel[0];
+  float ch1 = susChannel[GNDREF] - susChannel[1];
+  float ch2 = susChannel[GNDREF] - susChannel[2];
+  float ch3 = susChannel[GNDREF] - susChannel[3];
 
   // Calculation of x and y
-  xout = ((d - s) / 2) * (ch2 - ch3 - ch0 + ch1) / (ch0 + ch1 + ch2 + ch3);  //[mm]
-  yout = ((d - s) / 2) * (ch2 + ch3 - ch0 - ch1) / (ch0 + ch1 + ch2 + ch3);  //[mm]
+  float xout = ((D - S) / 2) * (ch2 - ch3 - ch0 + ch1) / (ch0 + ch1 + ch2 + ch3);  //[mm]
+  float yout = ((D - S) / 2) * (ch2 + ch3 - ch0 - ch1) / (ch0 + ch1 + ch2 + ch3);  //[mm]
 
   // Calculation of the angles
-  alphaBetaRaw[0] = atan2(xout, h) * (180 / M_PI);  //[°]
-  alphaBetaRaw[1] = atan2(yout, h) * (180 / M_PI);  //[°]
-}
-
-void SusConverter::calibration(const float coeffAlpha[9][10], const float coeffBeta[9][10]) {
-  uint8_t index, k, l;
-
-  // while loop iterates above all calibration cells to use the different calibration functions in
-  // each cell
-  k = 0;
-  while (k < 3) {
-    k++;
-    l = 0;
-    while (l < 3) {
-      l++;
-      // if-condition to check in which cell the data point has to be
-      if ((alphaBetaRaw[0] > ((completeCellWidth * ((k - 1) / 3.)) - halfCellWidth) &&
-           alphaBetaRaw[0] < ((completeCellWidth * (k / 3.)) - halfCellWidth)) &&
-          (alphaBetaRaw[1] > ((completeCellWidth * ((l - 1) / 3.)) - halfCellWidth) &&
-           alphaBetaRaw[1] < ((completeCellWidth * (l / 3.)) - halfCellWidth))) {
-        index = (3 * (k - 1) + l) - 1;  // calculate the index of the datapoint for the right cell
-        alphaBetaCalibrated[0] =
-            coeffAlpha[index][0] + coeffAlpha[index][1] * alphaBetaRaw[0] +
-            coeffAlpha[index][2] * alphaBetaRaw[1] +
-            coeffAlpha[index][3] * alphaBetaRaw[0] * alphaBetaRaw[0] +
-            coeffAlpha[index][4] * alphaBetaRaw[0] * alphaBetaRaw[1] +
-            coeffAlpha[index][5] * alphaBetaRaw[1] * alphaBetaRaw[1] +
-            coeffAlpha[index][6] * alphaBetaRaw[0] * alphaBetaRaw[0] * alphaBetaRaw[0] +
-            coeffAlpha[index][7] * alphaBetaRaw[0] * alphaBetaRaw[0] * alphaBetaRaw[1] +
-            coeffAlpha[index][8] * alphaBetaRaw[0] * alphaBetaRaw[1] * alphaBetaRaw[1] +
-            coeffAlpha[index][9] * alphaBetaRaw[1] * alphaBetaRaw[1] * alphaBetaRaw[1];  //[°]
-        alphaBetaCalibrated[1] =
-            coeffBeta[index][0] + coeffBeta[index][1] * alphaBetaRaw[0] +
-            coeffBeta[index][2] * alphaBetaRaw[1] +
-            coeffBeta[index][3] * alphaBetaRaw[0] * alphaBetaRaw[0] +
-            coeffBeta[index][4] * alphaBetaRaw[0] * alphaBetaRaw[1] +
-            coeffBeta[index][5] * alphaBetaRaw[1] * alphaBetaRaw[1] +
-            coeffBeta[index][6] * alphaBetaRaw[0] * alphaBetaRaw[0] * alphaBetaRaw[0] +
-            coeffBeta[index][7] * alphaBetaRaw[0] * alphaBetaRaw[0] * alphaBetaRaw[1] +
-            coeffBeta[index][8] * alphaBetaRaw[0] * alphaBetaRaw[1] * alphaBetaRaw[1] +
-            coeffBeta[index][9] * alphaBetaRaw[1] * alphaBetaRaw[1] * alphaBetaRaw[1];  //[°]
-      }
-    }
-  }
-}
-
-float* SusConverter::calculateSunVector() {
-  // Calculate the normalized Sun Vector
-  sunVectorSensorFrame[0] = -(tan(alphaBetaCalibrated[0] * (M_PI / 180)) /
-                              (sqrt((powf(tan(alphaBetaCalibrated[0] * (M_PI / 180)), 2)) +
-                                    powf(tan((alphaBetaCalibrated[1] * (M_PI / 180))), 2) + (1))));
-  sunVectorSensorFrame[1] = -(tan(alphaBetaCalibrated[1] * (M_PI / 180)) /
-                              (sqrt(powf((tan(alphaBetaCalibrated[0] * (M_PI / 180))), 2) +
-                                    powf(tan((alphaBetaCalibrated[1] * (M_PI / 180))), 2) + (1))));
-  sunVectorSensorFrame[2] =
-      -(-1 / (sqrt(powf((tan(alphaBetaCalibrated[0] * (M_PI / 180))), 2) +
-                   powf((tan(alphaBetaCalibrated[1] * (M_PI / 180))), 2) + (1))));
-
-  return sunVectorSensorFrame;
-}
-
-float* SusConverter::getSunVectorSensorFrame(const uint16_t susChannel[6],
-                                             const float coeffAlpha[9][10],
-                                             const float coeffBeta[9][10]) {
-  calcAngle(susChannel);
-  calibration(coeffAlpha, coeffBeta);
-  return calculateSunVector();
+  sunVectorSensorFrame[0] = -xout;
+  sunVectorSensorFrame[1] = -yout;
+  sunVectorSensorFrame[2] = H;
+  VectorOperations<float>::normalize(sunVectorSensorFrame, sunVectorSensorFrame, 3);
 }

mission/controller/acs/SusConverter.h

@@ -1,8 +1,4 @@
-#ifndef MISSION_CONTROLLER_ACS_SUSCONVERTER_H_
-#define MISSION_CONTROLLER_ACS_SUSCONVERTER_H_
-
-#include <fsfw/datapoollocal/LocalPoolVector.h>
-#include <stdint.h>
+#include <fsfw/globalfunctions/math/VectorOperations.h>
 
 #include "AcsParameters.h"
 
@@ -10,41 +6,26 @@ class SusConverter {
  public:
   SusConverter() {}
 
-  bool checkSunSensorData(const uint16_t susChannel[6]);
-
-  void calcAngle(const uint16_t susChannel[6]);
-  void calibration(const float coeffAlpha[9][10], const float coeffBeta[9][10]);
-  float* calculateSunVector();
-
-  float* getSunVectorSensorFrame(const uint16_t susChannel[6], const float coeffAlpha[9][10],
-                                 const float coeffBeta[9][10]);
+  uint64_t checkSunSensorData(const uint16_t susChannel[6]);
+  bool checkValidity(bool* susValid, const uint64_t brightness[12], const float threshold);
+  void calculateSunVector(float* sunVectorSensorFrame, const uint16_t susChannel[6]);
 
  private:
-  float alphaBetaRaw[2];          //[°]
-  float alphaBetaCalibrated[2];   //[°]
-  float sunVectorSensorFrame[3];  //[-]
-
-  bool validFlag[12] = {returnvalue::OK, returnvalue::OK, returnvalue::OK, returnvalue::OK,
-                        returnvalue::OK, returnvalue::OK, returnvalue::OK, returnvalue::OK,
-                        returnvalue::OK, returnvalue::OK, returnvalue::OK, returnvalue::OK};
-
   static const uint8_t GNDREF = 4;
-  uint16_t susChannelValueCheckHigh =
-      4096;  //=2^12[Bit]high borderline for the channel values of one sun sensor for validity Check
-  uint8_t susChannelValueCheckLow =
-      0;  //[Bit]low borderline for the channel values of one sun sensor for validity Check
-  uint16_t susChannelValueSumHigh =
-      100;  // 4096[Bit]high borderline for check if the sun sensor is illuminated by the sun or by
-            // the reflection of sunlight from the moon/earth
-  uint8_t susChannelValueSumLow =
-      0;  //[Bit]low borderline for check if the sun sensor is illuminated
-          // by the sun or by the reflection of sunlight from the moon/earth
-  uint8_t completeCellWidth = 140,
-          halfCellWidth = 70;  //[°] Width of the calibration cells --> necessary for checking in
-                               // which cell a data point should be
-  uint16_t susChannelValueSum = 0;
+  // =2^12[Bit]high borderline for the channel values of one sun sensor for validity Check
+  static constexpr uint16_t SUS_CHANNEL_VALUE_HIGH = 4096;
+  // [Bit]low borderline for the channel values of one sun sensor for validity Check
+  static constexpr uint8_t SUS_CHANNEL_VALUE_LOW = 0;
+  // 4096[Bit]high borderline for check if the sun sensor is illuminated by the sun or by the
+  // reflection of sunlight from the moon/earth
+  static constexpr uint16_t SUS_ALBEDO_CHECK = 1000;
+  // [Bit]low borderline for check if the sun sensor is illuminated by the sun or by the  reflection
+  // of sunlight from the moon/earth
+  static constexpr uint8_t SUS_CHANNEL_SUM_LOW = 0;
+
+  static constexpr float S = 0.03;  // S=[mm] gap between diodes
+  static constexpr float D = 5;     // D=[mm] edge length of the quadratic aperture
+  static constexpr float H = 2.5;   // H=[mm] distance between diodes and aperture
 
   AcsParameters acsParameters;
 };
-
-#endif /* MISSION_CONTROLLER_ACS_SUSCONVERTER_H_ */

mission/power/P60DockHandler.cpp

@@ -66,7 +66,7 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
   }
   coreHk.battMode = newBattMode;
 
-  auxHk.heaterOn = *(packet + 0x57);
+  auxHk.heaterForBp4PackOn = *(packet + 0x57);
   auxHk.converter5VStatus = *(packet + 0x58);
 
   for (uint8_t idx = 0; idx < hk::CHNLS_LEN; idx++) {
@@ -111,6 +111,8 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
   }
   coreHk.setValidity(true, true);
   auxHk.setValidity(true, true);
+  // No BP4 pack, no this is always invalid.
+  auxHk.heaterForBp4PackOn.setValid(false);
 }
 
 ReturnValue_t P60DockHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,

mission/power/gsDefs.h

@@ -260,7 +260,8 @@ class HkTableDataset : public StaticLocalDataSet<32> {
   lp_var_t<uint16_t> resetcause = lp_var_t<uint16_t>(sid.objectId, pool::P60DOCK_RESETCAUSE, this);
 
   /** Battery heater control only possible on BP4 packs */
-  lp_var_t<uint8_t> heaterOn = lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_HEATER_ON, this);
+  lp_var_t<uint8_t> heaterForBp4PackOn =
+      lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_HEATER_ON, this);
   lp_var_t<uint8_t> converter5VStatus =
       lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_CONV_5V_ENABLE_STATUS, this);
 

mission/sysDefs.h

@@ -44,6 +44,8 @@ static constexpr char VERSION_FILE_NAME[] = "version.txt";
 static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
 static constexpr char TIME_FILE_NAME[] = "time_backup.txt";
 
+static constexpr uint32_t SYS_ROM_BASE_ADDR = 0x80000000;
+
 static constexpr ActionId_t ANNOUNCE_VERSION = 1;
 static constexpr ActionId_t ANNOUNCE_CURRENT_IMAGE = 2;
 static constexpr ActionId_t ANNOUNCE_BOOT_COUNTS = 3;
@@ -51,6 +53,7 @@ static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
 static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
 static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
 static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
+static constexpr ActionId_t READ_REBOOT_MECHANISM_INFO = 9;
 
 static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
 static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
@@ -113,6 +116,10 @@ static constexpr Event TRYING_I2C_RECOVERY = event::makeEvent(SUBSYSTEM_ID, 10,
 static constexpr Event I2C_REBOOT = event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
 //! [EXPORT] : [COMMENT] PDEC recovery through reset was not possible, performing full reboot.
 static constexpr Event PDEC_REBOOT = event::makeEvent(SUBSYSTEM_ID, 12, severity::HIGH);
+//! [EXPORT] : [COMMENT] Version information of the firmware (not OBSW).
+//! P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash
+//! P2: First four letters of Git SHA is the last byte of P1 is set.
+static constexpr Event FIRMWARE_INFO = event::makeEvent(SUBSYSTEM_ID, 13, severity::INFO);
 
 class ListDirectoryCmdBase {
  public:  // TODO: Packet definition for clean deserialization
@@ -242,19 +249,22 @@ class CpHelperParser {
   CpHelperParser(const uint8_t* data, size_t maxLen) : data(data), maxLen(maxLen) {}
 
   ReturnValue_t parse() {
-    if (maxLen < 1) {
+    if (maxLen < 2) {
       return SerializeIF::STREAM_TOO_SHORT;
     }
     recursiveOpt = data[0];
-    return parseDestTargetString(data + 1, maxLen - 1, destTgt);
+    forceOpt = data[1];
+    return parseDestTargetString(data + 2, maxLen - 2, destTgt);
   }
   const SourceTargetPair& destTgtPair() const { return destTgt; }
   bool isRecursiveOptSet() const { return recursiveOpt; }
+  bool isForceOptSet() const { return forceOpt; }
 
  private:
   const uint8_t* data;
   size_t maxLen;
   bool recursiveOpt = false;
+  bool forceOpt = false;
   SourceTargetPair destTgt;
 };
 

mission/tcs/Max31865EiveHandler.cpp

@@ -37,6 +37,8 @@ void Max31865EiveHandler::doShutDown() {
     transitionOk = false;
   }
   if (state == InternalState::INACTIVE and transitionOk) {
+    sensorDataset.temperatureCelcius = thermal::INVALID_TEMPERATURE;
+    sensorDataset.setValidity(false, true);
     updatePeriodicReply(false, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
     setMode(MODE_OFF);
   }

mission/tcs/Tmp1075Handler.cpp

@@ -86,8 +86,11 @@ ReturnValue_t Tmp1075Handler::scanForReply(const uint8_t *start, size_t remainin
 ReturnValue_t Tmp1075Handler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   switch (id) {
     case TMP1075::GET_TEMP: {
-      int16_t tempValueRaw = 0;
-      tempValueRaw = packet[0] << 4 | packet[1] >> 4;
+      // Convert 12 bit MSB first raw temperature to 16 bit first.
+      int16_t tempValueRaw = static_cast<uint16_t>((packet[0] << 8) | packet[1]) >> 4;
+      // Sign extension to 16 bits: If the sign bit is set, fill up with ones on the left.
+      tempValueRaw = (packet[0] & 0x80) ? (tempValueRaw | 0xF000) : tempValueRaw;
+      // 0.0625 is the sensor sensitivity.
       float tempValue = ((static_cast<float>(tempValueRaw)) * 0.0625);
 #if OBSW_DEBUG_TMP1075 == 1
       sif::info << "Tmp1075 with object id: 0x" << std::hex << getObjectId()

mission/tmtc/PersistentTmStore.cpp

@@ -268,6 +268,10 @@ ReturnValue_t PersistentTmStore::getNextDumpPacket(PusTmReader& reader, bool& fi
     // restore the file dump, but for now do not trust the file.
     std::error_code e;
     std::filesystem::remove(dumpParams.dirEntry.path().c_str(), e);
+    if (dumpParams.dirEntry.path() == activeFile) {
+      activeFile == std::nullopt;
+      assignAndOrCreateMostRecentFile();
+    }
     fileHasSwapped = true;
     return loadNextDumpFile();
   }

mission/tmtc/PusLiveDemux.cpp

@@ -11,23 +11,20 @@ ReturnValue_t PusLiveDemux::demultiplexPackets(StorageManagerIF& tmStore,
   ReturnValue_t result = returnvalue::OK;
   for (unsigned int idx = 0; idx < destinations.size(); idx++) {
     const auto& dest = destinations[idx];
-    if (destinations.size() > 1) {
-      if (idx < destinations.size() - 1) {
-        // Create copy of data to ensure each TM recipient has its own copy. That way, we don't need
-        // to bother with send order and where the data is deleted.
-        store_address_t storeId;
-        result = tmStore.addData(&storeId, tmData, tmSize);
-        if (result == returnvalue::OK) {
-          message.setStorageId(storeId);
-        } else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-          sif::error << "PusLiveDemux::handlePacket: Store too full to create data copy"
-                     << std::endl;
-#endif
-        }
+    if ((destinations.size() > 1) and (idx < (destinations.size() - 1))) {
+      // Create copy of data to ensure each TM recipient has its own copy. That way, we don't need
+      // to bother with send order and where the data is deleted.
+      store_address_t storeId;
+      result = tmStore.addData(&storeId, tmData, tmSize);
+      if (result == returnvalue::OK) {
+        message.setStorageId(storeId);
       } else {
-        message.setStorageId(origStoreId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+        sif::error << "PusLiveDemux::handlePacket: Store too full to create data copy" << std::endl;
+#endif
       }
+    } else {
+      message.setStorageId(origStoreId);
     }
     result = ownerQueue.sendMessage(dest.queueId, &message);
     if (result != returnvalue::OK) {