Merge pull request 'prep next release' (#801) from prep_v7.0.0 into main

Reviewed-on: #801
Reviewed-by: Marius Eggert <eggertm@irs.uni-stuttgart.de>

.idea/cmake.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="CMakeSharedSettings">
     <configurations>
-      <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Q7S" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
+      <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Default" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
         <ADDITIONAL_GENERATION_ENVIRONMENT>
           <envs>
             <env name="ZYNQ_7020_ROOTFS" value="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi" />
@@ -10,6 +10,7 @@
           </envs>
         </ADDITIONAL_GENERATION_ENVIRONMENT>
       </configuration>
+      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" NO_GENERATOR="true" />
     </configurations>
   </component>
 </project>

CHANGELOG.md

@@ -16,7 +16,339 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
-# [v4.0.0] to be released
+# [v7.0.0] 2023-10-11
+
+- Bumped `eive-tmtc` to v5.7.1.
+- Bumped `eive-fsfw`
+
+## Added
+
+- EPS Subsystem has been added to EIVE System Tree
+- Power Controller for calculating the State of Charge and FDIR regarding low SoC has been
+  introduced.
+
+## Changed
+
+- Changed internals for MPSoC boot process to make the code more understandable and some
+  parameters better configurable. This should not affect the behaviour of the OBSW, but might
+  make it more reliable and fix some corner cases.
+
+## Fixed
+
+- Missing `nullptr` checks for PLOC Supervisor handler, which could lead to crashes.
+- SCEX bugfix for normal and transition commanding.
+
+# [v6.6.0] 2023-09-18
+
+## Changed
+
+- Changed the memory initialized for the PDEC Config Memory and the PDEC RAM by using `mmap`
+  directly and ignoring UIO. This makes the OBSW compatible to a device tree update, where those
+  memory segments are marked reserved and are thus not properly accessible through the UIO API
+  anymore. This change should be downwards compatible to older device trees.
+
+# [v6.5.1] 2023-09-12
+
+- Bumped `eive-tmtc` to v5.5.0.
+
+# [v6.5.0] 2023-09-12
+
+## Changed
+
+- Relaxed SUS FDIR. The devices have shown to be glitchy in orbit, but still seem to deliver
+  sensible raw values most of the time. Some further testing is necessary, but some changes in the
+  code should cause the SUS devices to remain healthy for now.
+- The primary and the secondary temperature sensors for the PLOC mission boards are exchanged.
+- ACS parameters for the SUSMGM (FLP) safe mode have been adjusted. This safe mode is now the
+  default one.
+- MGM3100 Startup Configuration: Ignore bit 1 of the CMM reply, which is sometimes set to
+  1 in the reply for some reason.
+
+# [v6.4.1] 2023-08-21
+
+## Fixed
+
+- `PDEC_CONFIG_CORRUPTED` event now actually contains the readback instead of the expected
+  config
+- Magnetic field vector was not calculated if only MGM4 was available, but still written to
+  the dataset. This would result in a NaN vector. Allowance for usage of MGM4 is now checked
+  before entering calculation.
+
+# [v6.4.0] 2023-08-16
+
+- `eive-tmtc`: v5.4.3
+
+## Fixed
+
+- The handling function of the GPS data is only called once per GPS read. This should remove
+  the fake fix-has-changed events.
+- Fix for PLOC SUPV HK set parsing.
+- The timestamp for the `POSSIBLE_FILE_CORRUPTION` event will be generated properly now.
+
+## Changed
+
+- PDEC FDIR rework: A full PDEC reboot will now only be performed after a regular PDEC reset has
+  failed 10 times. The mechanism will reset after no PDEC reset has happended for 2 minutes.
+  The PDEC reset will be performed when counting 4 dirty frame events 10 seconds after the count
+  was incremented initially.
+- GPS Fix has changed event is no longer triggered for the EM
+- MGM and SUS rates now will only be calculated, if 2 valid consecutive datapoints are available.
+  The stored value of the last timestep will now be reset, if no actual value is available.
+
+## Added
+
+- The PLOC SUPV HK set is requested and downlinked periodically if the SUPV is on now.
+- SGP4 Propagator is now used for propagating the position of EIVE. It will only work once
+  a TLE has been uploaded with the newly added action command for the ACS Controller. In
+  return the actual GPS data will be ignored once SPG4 is running. However, by setting the
+  according parameter, the ACS Controller can be directed to ignore the SGP4 solution.
+- Skyview dataset for more GPS TM has been added
+- `PDEC_CONFIG_CORRUPTED` event which is triggered when the PDEC configuration does not match the
+  expected configuration. P1 will contain the readback of the first word and P2 will contain the
+  readback of the second word.
+- The MGM and SUS vectors being too close together does not prevent the usage of the safe
+  mode controller anymore.
+- Parameter to disable usage of MGM4, which is part of the MTQ and therefore cannot be
+  disabled without disabling the MTQ itself.
+
+# [v6.3.0] 2023-08-03
+
+## Fixed
+
+- Small SCEX fix: The temperatur check option was not passed
+  on for commands with a user data size larger than 1.
+- SCEX: Properly check whether filesystem is usable for filesystem checks.
+- ACS Controller strategy is now actually written to the dataset for detumbling.
+- During detumble the fused rotation rate is now calculated.
+- Detumbling is now exited when its exit value is undercut and not its entry value.
+- Rotation rate of last cycle is now stored in all cases for the fused rotational rate
+  calculation.
+- Fused rotation rate estimation during eclipse can be disabled. This will also prevent
+  detumbling during eclipse, as no relevant rotational rate is available for now.
+- `EiveSystem`: Add a small delay between triggering an event for FDIR reboots and sending the
+  command to the core controller.
+- PL PDU: Fixed bounds checking logic. Bound checks will only be performed for modules which are
+  enabled.
+
+## Changed
+
+- SCEX: Only perform filesystem checks when not in OFF mode.
+- The `EiveSystem` now only sends reboot commands targetting the same image.
+- Added 200 ms delay between switching HPA/MPA/TX/X8 and DRO GPIO pin OFF.
+- PL PCDU ADC set is now automatically enabled for `NORMAL` mode transitions. It is automatically
+  disabled for `OFF` mode transitions.
+
+## Added
+
+- PL PCDU for EM build.
+- SCEX: Add warning event if filesystem is unusable.
+
+# [v6.2.0] 2023-07-26
+
+- `eive-tmtc`: v5.3.1
+
+## Changed
+
+- STR missed reply handling is now moved to DHB rather than the COM interface. The COM IF will
+  still trigger an event if a reply is taking too long, and FDIR should still work via reply
+  timeouts.
+- Re-ordered some functions of the core controller in the initialize function.
+- Rad sensor is now only polled every 30 minutes instead of every device cycle to reduce wear of
+  the RADFET electronics.
+- The SD cards will still be switched OFF on a reboot, but this is done in a non-blocking manner
+  now with a timeout of 10 seconds where the reboot will be performed in any case.
+- ACS Controller now includes the safe mode from FLP, which will calculate its rotational rate
+  from SUS and MGM measurements. To accommodate these changes, low-pass filters for SUS
+  measurements and rates as well as MGM measurements and rates are included. Usage of the new
+  controller as well as settings of the low-pass filters can be handled via parameter commands.
+- Simplify and fix the chip and copy protection functions in the core controller. This mechanism
+  now is always performed for the target chip and target copy in the reboot handlers.
+- Improvement in FSFW: HK generation is now countdown based.
+
+## Added
+
+- 5 ms delay after pulling RADFET enable pin high before starting
+  the ADC conversion.
+- Set STR time in configuration sequence to firmware mode.
+- The STR `AutoThreshold` parameters are now set from the configuration JSON file at STR
+  startup.
+- The STR handler can now handle the COM error reply and triggers an low severity event accordingly.
+- Add SCEX handler for EM.
+- Radiation sensor handler dummy for the EM.
+- Added event for SD card information in core controller initialize function. This event will also
+  be triggered after the SD state machine has run, so the event will generally be triggered twice
+  at system boot, and once after commanding SD card switches.
+
+## Fixed
+
+- General bugs in the SD card state machine. This might fix some other known bugs for certain
+  combinations of switching ON and OFF SD cards and also makes the whole state machine a lot more
+  robust against hanging up.
+- SUS dummy handler went to `MODE_NORMAL` for ON commands.
+- PL PCDU dummy went to `MODE_NORMAL` for ON commands.
+
+# [v6.1.0] 2023-07-13
+
+- `eive-tmtc`: v5.2.0
+
+## Changed
+
+- TCS: Remove OBC IF board thermal module, which is exactly identical to OBC module and therefore
+  obsolete.
+- Swapped PL and PS I2C, BPX battery and MGT are connected to PS I2C now for firmware versions
+  equal or above v4. However, this software version is compatible to both v3 and v4 of the firmware.
+- The firmware version variables are global statics inititalized early during the program
+  runtime now. This makes it possible to check the firmware version earlier.
+- The TCS controller will now always command heaters OFF when being blind for thermal
+  components (no sensors available), irrespective of current switch state.
+- Make OBSW compatible to prospective FW version v5.0.0, where the Q7 I2C devices were
+  moved to a PL I2C block and the TMP sensor devices were moved to the PS I2C0.
+- Made `Xadc` code a little bit more robust against errors.
+
+## Fixed
+
+- TMP1075: Set dataset invalid on shutdown explicitely
+- Small fixes for TMP1075 FDIR: Use strange and missed reply counters.
+- TCS controller: Last heater (S-band heater) was skipped for transition completion
+  checks.
+- TCS controller: A helper member to track the elapsed heater control cycles was not reset
+  properly, which could lead to switch transitions being completed immediately. This can
+  lead to weird bugs like heaters being commanded ON twice and can potentially lead to
+  other bugs.
+- TMP1075: Devices did not go to OFF mode when being set faulty.
+- Update PL PCDU 1 in TCS mode tree on the EM.
+- TMP1075: Possibly ignored health commands.
+- Bugfix in FSFW where certain packet types could only be sent with source data fields with a
+  maximum size of 255 bytes.
+- TCS CTRL: Limit number of heater handler messages sent in case there are not sensors available
+  anymore.
+- Fix to allow adding real STR device for EM.
+
+# Added
+
+- Two events for heaters being commanded ON and OFF by the TCS controller
+- Upper limit for burn time of TCS heaters. Currently set to 1 hour for each heater.
+  This mechanism will only track the burn time for heaters which were commanded by the
+  TCS controller.
+- TCS controller is now observable by introducing a new HK dataset which exposes some internal
+  fields related to TCS control.
+
+# [v6.0.0] 2023-07-02
+
+- `q7s-package` version v3.2.0
+- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
+
+## Changed
+
+- Added back PTME busy bit polling. This is necessary due to changes to the AXI APB interface
+  to the PTME core.
+
+## Fixed
+
+- For the live channel (VC0), telemetry was still only dumped if the transmitter is active.
+  Please note that this fix will lead to crashes for FW versions below v3.2.
+  However, it might not be an issue for the oldest firmware on the satellite (v2.5.1).
+
+# [v5.2.0] 2023-07-02
+
+## Fixed
+
+- The firmware information event was not triggered even when possible because of an ordering
+  bug in the initializer function.
+- Empty dumps (no TM in time range) will now correctly be completed immediately
+
+## Changed
+
+- PTME was always reset on submode changes. The reset will now only be performed if the actual data
+  rate changes.
+- Add back ACS board code for the EM. Now that the radiation sensor was removed, the image switching
+  issue has disappeared and adding back the ACS board is worth it for the GPS timekeeping.
+
+# [v5.1.0] 2023-06-28
+
+- `eive-tmtc` version v5.1.0
+
+## Changed
+
+- Persistent TM store dumps are now performed in chronological order.
+- Increase Syrlinks RX HK rate to 5.0 seconds during a pass.
+- Various robustness improvements for the heater handler. The heater handler will now only
+  process the command queue if it is not busy with switch commanding which reduces the amount
+  of possible bugs.
+- The heater handler is only able to process messages stricly sequentially now but is scheduled
+  twice in a 0.5 second slot so something like a consecutive heater ON or OFF command can still
+  be handled relatively quickly.
+
+## Added
+
+- Sequence counters for PUS and CFDP packets are now stored persistently across graceful reboots.
+- The PUS packet message type counter will now be incremented properly for each PUS service.
+- Internal error reporter set is now enabled by default and generated every 120 seconds.
+
+# [v5.0.0] 2023-06-26
+
+v3.3.1 and all following version will now be moved to v5.0.0 with the additional changes listed
+here. This was done because the firmware update (v4.0.0) is not working right now and it is not
+known when and how it will be fixed. Because of that, all updates to make the SW work with the new
+firmware, which are limited to a few files will be moved to a dev branch so regular development
+compatible to the old firmware can continue.
+
+TLDR: This version is compatible to the old firmware and some changes which only work with the new
+firmware have been reverted.
+
+## Changed
+
+- Added `sync` syscall in graceful shutdown handler
+- Graceful shutdown is now performed by the reboot watchdog
+- There is now a separate file for the total reboot counter. The reboot watchdog has its own local
+  counters to determine whether a reboot is necessary.
+
+# [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.1] 2023-06-22
+
+## Fixed
+
+- `PusLiveDemux` packet demultiplexing bugfix where the demultiplexing did not work when there was
+  only one destination available.
+
+## Fixed
+
+- Fixed H parameter in SUS converter from 1 mm to 2.5 mm.
 
 # [v3.3.0] 2023-06-21
 

CMakeLists.txt

@@ -9,8 +9,8 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 3)
-set(OBSW_VERSION_MINOR 3)
+set(OBSW_VERSION_MAJOR 7)
+set(OBSW_VERSION_MINOR 0)
 set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -93,7 +93,7 @@ set(OBSW_ADD_BPX_BATTERY_HANDLER
     1
     CACHE STRING "Add BPX battery module")
 set(OBSW_ADD_STAR_TRACKER
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Startracker module")
 set(OBSW_ADD_SUN_SENSORS
     ${INIT_VAL}
@@ -105,7 +105,7 @@ set(OBSW_ADD_THERMAL_TEMP_INSERTER
     ${OBSW_Q7S_EM}
     CACHE STRING "Add thermal sensor temperature inserter")
 set(OBSW_ADD_ACS_BOARD
-    ${INIT_VAL}
+    1
     CACHE STRING "Add ACS board module")
 set(OBSW_ADD_GPS_CTRL
     ${INIT_VAL}
@@ -144,13 +144,13 @@ set(OBSW_ADD_RAD_SENSORS
     ${INIT_VAL}
     CACHE STRING "Add Rad Sensor module")
 set(OBSW_ADD_PL_PCDU
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Payload PCDU modukle")
 set(OBSW_ADD_SYRLINKS
     1
     CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
-    ${INIT_VAL}
+    1
     CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
     1
@@ -162,7 +162,7 @@ set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")
 set(OBSW_ADD_SCEX_DEVICE
-    ${INIT_VAL}
+    1
     CACHE STRING "Add Solar Cell Experiment module")
 set(OBSW_SYRLINKS_SIMULATED
     0
@@ -240,6 +240,9 @@ set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
 set(EIVE_ADD_LINUX_FILES OFF)
 set(FSFW_ADD_TMSTORAGE ON)
 
+set(FSFW_ADD_COORDINATES ON)
+set(FSFW_ADD_SGP4_PROPAGATOR ON)
+
 # Analyse different OS and architecture/target options, determine BSP_PATH,
 # display information about compiler etc.
 pre_source_hw_os_config()

README.md

@@ -964,6 +964,12 @@ used by other software components to read the current chip and copy.
 This is a configuration scripts which runs after the Network Time Protocol has run. This script
 currently sets the static IP address `192.168.133.10` and starts the `can` interface.
 
+## Initial boot delay
+
+You can create a file named `boot_delays_secs.txt` inside the home folder to delay the OBSW boot
+for 6 seconds if the file is empty of for the number of seconds specified inside the file. This
+can be helpful if something inside the OBSW leads to an immediate crash of the OBC.
+
 ## PCDU
 
 Connect to serial console of P60 Dock

bsp_hosted/ObjectFactory.cpp

@@ -68,7 +68,7 @@ void ObjectFactory::produce(void* args) {
 #endif
   auto sdcMan = new DummySdCardManager("/tmp");
   ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores, 120);
+                                       &tmStore, persistentStores, 120, enableHkSets);
 
   new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
   auto* dummyGpioIF = new DummyGpioIF();
@@ -113,7 +113,7 @@ void ObjectFactory::produce(void* args) {
   if (heaterHandler == nullptr) {
     sif::error << "HeaterHandler could not be created" << std::endl;
   } else {
-    ObjectFactory::createThermalController(*heaterHandler);
+    ObjectFactory::createThermalController(*heaterHandler, true);
   }
   new TestTask(objects::TEST_TASK);
 }

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 313 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateEvents.h"
 
@@ -100,10 +100,16 @@ const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
 const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +133,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +147,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -166,6 +175,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -260,6 +270,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -277,6 +288,8 @@ 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 *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_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";
@@ -285,6 +298,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -300,6 +316,8 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -493,6 +511,8 @@ const char *translateEvents(Event event) {
       return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -501,6 +521,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -547,6 +577,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -571,6 +605,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -625,6 +661,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -813,6 +851,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -847,6 +887,10 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -863,6 +907,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -893,6 +943,10 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,14 +1,15 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 171 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Contains 173 translations.
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateObjects.h"
 
 const char *TEST_TASK_STRING = "TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
@@ -164,6 +165,7 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -186,6 +188,8 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
     case 0x43400001:
@@ -496,6 +500,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

bsp_q7s/CMakeLists.txt

@@ -7,7 +7,8 @@ target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC ${LIB_FSFW_NAME})
 target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
 add_subdirectory(simple)
 
-target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)
+target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp scheduling.cpp
+                                   objectFactory.cpp)
 
 add_subdirectory(boardtest)
 

bsp_q7s/boardconfig/busConf.h

@@ -12,6 +12,9 @@ static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
 //! I2C bus using the I2C peripheral of the ARM processing system (PS)
 static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";
+//! I2C bus using the first I2C peripheral of the ARM processing system (PS).
+//! Named like this because it is used by default for the Q7 devices.
+static constexpr char I2C_Q7_EIVE[] = "/dev/i2c_q7";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
@@ -23,6 +26,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 +61,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 +87,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/boardtest/Q7STestTask.cpp

@@ -218,15 +218,30 @@ void Q7STestTask::testProtHandler() {
   bool opPerformed = false;
   ReturnValue_t result = returnvalue::OK;
   // If any chips are unlocked, lock them here
-  result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
-                                                 opPerformed, true);
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_0, xsc::Copy::COPY_0,
+                                                              true);
+  if (result != returnvalue::OK) {
+    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+  }
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_0, xsc::Copy::COPY_1,
+                                                              true);
+  if (result != returnvalue::OK) {
+    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+  }
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_0,
+                                                              true);
+  if (result != returnvalue::OK) {
+    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
+  }
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
+                                                              true);
   if (result != returnvalue::OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
 
   // unlock own copy
-  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
-                                                 opPerformed, true);
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::SELF_CHIP,
+                                                              xsc::Copy::SELF_COPY, false);
   if (result != returnvalue::OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -239,8 +254,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock own copy
-  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
-                                                 opPerformed, true);
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::SELF_CHIP,
+                                                              xsc::Copy::SELF_COPY, true);
   if (result != returnvalue::OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -253,8 +268,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // unlock specific copy
-  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
-                                                 opPerformed, true);
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
+                                                              false);
   if (result != returnvalue::OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -267,8 +282,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock specific copy
-  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
-                                                 opPerformed, true);
+  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
+                                                              true);
   if (result != returnvalue::OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }

bsp_q7s/core/CMakeLists.txt

@@ -1,4 +1 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp scheduling.cpp
-                                    ObjectFactory.cpp WatchdogHandler.cpp)
-
-target_sources(${SIMPLE_OBSW_NAME} PRIVATE scheduling.cpp)
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)

bsp_q7s/core/CoreController.h

@@ -1,11 +1,13 @@
 #ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
+#include <bsp_q7s/core/defs.h>
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #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>
@@ -13,7 +15,6 @@
 #include <atomic>
 #include <cstddef>
 
-#include "CoreDefinitions.h"
 #include "OBSWConfig.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
@@ -23,7 +24,7 @@
 class Timer;
 class SdCardManager;
 
-struct RebootFile {
+struct RebootWatchdogFile {
   static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
 
   bool enabled = true;
@@ -44,6 +45,93 @@ struct RebootFile {
   xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
+class RebootWatchdogPacket : public SerialLinkedListAdapter<SerializeIF> {
+ public:
+  RebootWatchdogPacket(RebootWatchdogFile& 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;
+};
+
+struct RebootCountersFile {
+  // 16 bit values so all boot counters fit into one event.
+  uint16_t img00Cnt = 0;
+  uint16_t img01Cnt = 0;
+  uint16_t img10Cnt = 0;
+  uint16_t img11Cnt = 0;
+};
+
+class RebootCountersPacket : public SerialLinkedListAdapter<SerializeIF> {
+  RebootCountersPacket(RebootCountersFile& rf) {
+    img00Count = rf.img00Cnt;
+    img01Count = rf.img01Cnt;
+    img10Count = rf.img10Cnt;
+    img11Count = rf.img11Cnt;
+    setLinks();
+  }
+
+ private:
+  void setLinks() {
+    setStart(&img00Count);
+    img00Count.setNext(&img01Count);
+    img01Count.setNext(&img10Count);
+    img10Count.setNext(&img11Count);
+    setLast(&img11Count);
+  }
+
+  SerializeElement<uint16_t> img00Count = 0;
+  SerializeElement<uint16_t> img01Count = 0;
+  SerializeElement<uint16_t> img10Count = 0;
+  SerializeElement<uint16_t> img11Count = 0;
+};
+
 class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
  public:
   enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
@@ -57,10 +145,15 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
 
   const std::string VERSION_FILE =
       "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::VERSION_FILE_NAME);
-  const std::string REBOOT_FILE =
-      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_FILE_NAME);
+  const std::string LEGACY_REBOOT_WATCHDOG_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" +
+      std::string(core::LEGACY_REBOOT_WATCHDOG_FILE_NAME);
+  const std::string REBOOT_WATCHDOG_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_WATCHDOG_FILE_NAME);
   const std::string BACKUP_TIME_FILE =
       "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_FILE_NAME);
+  const std::string REBOOT_COUNTERS_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_COUNTER_FILE_NAME);
 
   static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
   static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
@@ -106,8 +199,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
    * @param updateProtFile Specify whether the protection info file is updated
    * @return
    */
-  ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
-                                      bool& protOperationPerformed, bool updateProtFile = true);
+  ReturnValue_t setBootCopyProtectionAndUpdateFile(xsc::Chip targetChip, xsc::Copy targetCopy,
+                                                   bool protect);
 
   bool sdInitFinished() const;
 
@@ -142,6 +235,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
 
   static constexpr bool BLOCKING_SD_INIT = false;
 
+  uint32_t* mappedSysRomAddr = nullptr;
   SdCardManager* sdcMan = nullptr;
   MessageQueueIF* eventQueue = nullptr;
 
@@ -191,7 +285,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   std::array<uint8_t, 1024> dirListingBuf{};
   DirListingDumpContext dumpContext{};
 
-  RebootFile rebootFile = {};
+  RebootWatchdogFile rebootWatchdogFile = {};
+  RebootCountersFile rebootCountersFile = {};
 
   CommandExecutor cmdExecutor;
   SimpleRingBuffer cmdReplyBuf;
@@ -209,12 +304,10 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);
 
   /**
-   * Index 0: Chip 0 Copy 0
-   * Index 1: Chip 0 Copy 1
-   * Index 2: Chip 1 Copy 0
-   * Index 3: Chip 1 Copy 1
+   * First index: Chip.
+   * Second index: Copy.
    */
-  std::array<bool, 4> protArray;
+  bool protArray[2][2]{};
   PeriodicOperationDivider opDivider5;
   PeriodicOperationDivider opDivider10;
 
@@ -261,12 +354,14 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
   void executeNextExternalSdCommand();
   void checkExternalSdCommandStatus();
-  void performRebootFileHandling(bool recreateFile);
+  void performRebootWatchdogHandling(bool recreateFile);
+  void performRebootCountersHandling(bool recreateFile);
 
   ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
                                             const uint8_t* data, size_t size);
   ReturnValue_t actionListDirectoryDumpDirectly(ActionId_t actionId, MessageQueueId_t commandedBy,
                                                 const uint8_t* data, size_t size);
+  ReturnValue_t performGracefulShutdown(xsc::Chip targetChip, xsc::Copy targetCopy);
 
   ReturnValue_t actionListDirectoryCommonCommandCreator(const uint8_t* data, size_t size,
                                                         std::ostringstream& oss);
@@ -277,16 +372,20 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   ReturnValue_t gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy, bool& protOpPerformed);
 
   ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
-  int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
-                                bool& protOperationPerformed, bool selfChip, bool selfCopy,
-                                bool allChips, bool allCopies, uint8_t arrIdx);
-  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
-                                 xsc::Copy& tgtCopy);
-  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  ReturnValue_t handleSwitchingSdCardsOffNonBlocking();
+  bool handleBootCopyProt(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect);
+  void rebootWatchdogAlgorithm(RebootWatchdogFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                               xsc::Copy& tgtCopy);
+  void resetRebootWatchdogCounters(xsc::Chip tgtChip, xsc::Copy tgtCopy);
   void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
-  bool parseRebootFile(std::string path, RebootFile& file);
-  void rewriteRebootFile(RebootFile file);
+  bool parseRebootWatchdogFile(std::string path, RebootWatchdogFile& file);
+  bool parseRebootCountersFile(std::string path, RebootCountersFile& file);
+  void rewriteRebootWatchdogFile(RebootWatchdogFile file);
+  void rewriteRebootCountersFile(RebootCountersFile file);
   void announceBootCounts();
+  void announceVersionInfo();
+  void announceCurrentImageInfo();
+  void announceSdInfo(SdCardManager::SdStatePair sdStates);
   void readHkData();
   void dirListingDumpHandler();
   bool isNumber(const std::string& s);

bsp_q7s/core/defs.h

@@ -1,10 +1,16 @@
-#ifndef BSP_Q7S_CORE_COREDEFINITIONS_H_
-#define BSP_Q7S_CORE_COREDEFINITIONS_H_
+#ifndef BSP_Q7S_CORE_DEFS_H_
+#define BSP_Q7S_CORE_DEFS_H_
 
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 
 namespace core {
 
+extern uint8_t FW_VERSION_MAJOR;
+extern uint8_t FW_VERSION_MINOR;
+extern uint8_t FW_VERSION_REVISION;
+extern bool FW_VERSION_HAS_SHA;
+extern char FW_VERSION_GIT_SHA[4];
+
 static const uint8_t HK_SET_ENTRIES = 3;
 static const uint32_t HK_SET_ID = 5;
 
@@ -36,4 +42,4 @@ class HkSet : public StaticLocalDataSet<HK_SET_ENTRIES> {
 
 }  // namespace core
 
-#endif /* BSP_Q7S_CORE_COREDEFINITIONS_H_ */
+#endif /* BSP_Q7S_CORE_DEFS_H_ */

bsp_q7s/em/emObjectFactory.cpp

@@ -1,4 +1,5 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <bsp_q7s/objectFactory.h>
 #include <dummies/ComCookieDummy.h>
 #include <dummies/PcduHandlerDummy.h>
 #include <fsfw/health/HealthTableIF.h>
@@ -10,8 +11,8 @@
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
+#include "common/config/devices/addresses.h"
 #include "devConf.h"
 #include "dummies/helperFactory.h"
 #include "eive/objects.h"
@@ -35,18 +36,20 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   PersistentTmStores stores;
+  readFirmwareVersion();
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
-                                       200);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
+                                       enableHkSets);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
   SpiComIF* spiMainComIF = nullptr;
   I2cComIF* i2cComIF = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
+  // Adding GPIOs for chip select decoding and initializing them.
   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.
@@ -59,17 +62,41 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
   dummyCfg.addPlocDummies = false;
 #endif
+#if OBSW_ADD_TMP_DEVICES == 1
+  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+  createTmpComponents(tmpDevsToAdd);
+  dummy::Tmp1075Cfg tmpCfg{};
+  tmpCfg.addTcsBrd0 = true;
+  tmpCfg.addTcsBrd1 = true;
+  tmpCfg.addPlPcdu0 = false;
+  tmpCfg.addPlPcdu1 = false;
+  tmpCfg.addIfBrd = false;
+  dummyCfg.tmp1075Cfg = tmpCfg;
+#endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
   // The ACU broke.
   dummyCfg.addOnlyAcuDummy = true;
 #endif
+#if OBSW_ADD_STAR_TRACKER == 1
+  dummyCfg.addStrDummy = false;
+#endif
+#if OBSW_ADD_SCEX_DEVICE == 0
+  dummyCfg.addScexDummy = true;
+#endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   dummyCfg.addBpxBattDummy = false;
 #endif
 #if OBSW_ADD_ACS_BOARD == 1
   dummyCfg.addAcsBoardDummies = false;
 #endif
+#if OBSW_ADD_PL_PCDU == 0
+  dummyCfg.addPlPcduDummy = true;
+#endif
 
   PowerSwitchIF* pwrSwitcher = nullptr;
 #if OBSW_ADD_GOMSPACE_PCDU == 0
@@ -79,28 +106,28 @@ void ObjectFactory::produce(void* args) {
 #endif
   satsystem::EIVE_SYSTEM.setI2cRecoveryParams(pwrSwitcher);
 
+  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
+  }
+  static_cast<void>(battAndImtqI2cDev);
+
+#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
+  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
+#endif
+  createPowerController(true, enableHkSets);
+
   dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF, enableHkSets);
 
   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);
+  auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
+  static_cast<void>(stackHandler);
 
-  // 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);
+  // Initialize chip select to avoid SPI bus issues.
+  createRadSensorChipSelect(gpioComIF);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  // Still initialize chip select to avoid SPI bus issues.
-  createRadSensorChipSelect(gpioComIF);
   createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
                            adis1650x::Type::ADIS16507);
 #else
@@ -111,7 +138,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets);
+  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
 
 #if OBSW_ADD_SYRLINKS == 1
@@ -122,14 +149,13 @@ void ObjectFactory::produce(void* args) {
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 #endif
 
-#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets);
-#endif
-
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
+#if OBSW_ADD_PL_PCDU == 1
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
+#endif
   createPayloadComponents(gpioComIF, *pwrSwitcher);
 
 #if OBSW_ADD_CCSDS_IP_CORES == 1
@@ -155,6 +181,6 @@ void ObjectFactory::produce(void* args) {
   createAcsController(true, enableHkSets);
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-  createThermalController(*heaterHandler);
-  satsystem::init();
+  createThermalController(*heaterHandler, true);
+  satsystem::init(true);
 }

bsp_q7s/fmObjectFactory.cpp

@@ -1,4 +1,5 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <bsp_q7s/objectFactory.h>
 #include <devices/gpioIds.h>
 #include <fsfw/storagemanager/LocalPool.h>
 #include <fsfw/storagemanager/PoolManager.h>
@@ -7,9 +8,9 @@
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
 #include "devConf.h"
+#include "devices/addresses.h"
 #include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
@@ -32,9 +33,10 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   PersistentTmStores stores;
+  readFirmwareVersion();
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
-                                       200);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
+                                       true);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -45,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);
 
   new CoreController(objects::CORE_CONTROLLER, enableHkSets);
   createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
@@ -66,24 +69,42 @@ void ObjectFactory::produce(void* args) {
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
 #if OBSW_ADD_TMP_DEVICES == 1
-  createTmpComponents();
+  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      // damaged
+      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
+
+  createTmpComponents(tmpDevsToAdd);
 #endif
   createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
-  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
-#if OBSW_ADD_SYRLINKS == 1
-  createSyrlinksComponents(pwrSwitcher);
-#endif /* OBSW_ADD_SYRLINKS == 1 */
-  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  createPayloadComponents(gpioComIF, *pwrSwitcher);
 
+  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
+  if (core::FW_VERSION_MAJOR >= 4) {
+    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
+  }
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets);
+  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets);
+  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
+  createPowerController(true, enableHkSets);
+
+#if OBSW_ADD_PL_PCDU == 1
+  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
+#endif
+#if OBSW_ADD_SYRLINKS == 1
+  createSyrlinksComponents(pwrSwitcher);
+#endif /* OBSW_ADD_SYRLINKS == 1 */
+
+  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
+  createPayloadComponents(gpioComIF, *pwrSwitcher);
 
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
@@ -112,7 +133,7 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   createMiscComponents();
-  createThermalController(*heaterHandler);
+  createThermalController(*heaterHandler, false);
   createAcsController(true, enableHkSets);
-  satsystem::init();
+  satsystem::init(false);
 }

bsp_q7s/fs/SdCardManager.cpp

@@ -125,13 +125,8 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
   return mountSdCard(sdCard);
 }
 
-ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard,
-                                             SdStatePair* statusPair) {
-  std::pair<sd::SdState, sd::SdState> active;
-  ReturnValue_t result = getSdCardsStatus(active);
-  if (result != returnvalue::OK) {
-    return result;
-  }
+ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, SdStatePair& sdStates,
+                                             bool doUnmountSdCard) {
   if (doUnmountSdCard) {
     if (not blocking) {
       sif::warning << "SdCardManager::switchOffSdCard: Two-step command but manager is"
@@ -147,17 +142,17 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSd
     return returnvalue::FAILED;
   }
   if (sdCard == sd::SdCard::SLOT_0) {
-    if (active.first == sd::SdState::OFF) {
+    if (sdStates.first == sd::SdState::OFF) {
       return ALREADY_OFF;
     }
   } else if (sdCard == sd::SdCard::SLOT_1) {
-    if (active.second == sd::SdState::OFF) {
+    if (sdStates.second == sd::SdState::OFF) {
       return ALREADY_OFF;
     }
   }
 
   if (doUnmountSdCard) {
-    result = unmountSdCard(sdCard);
+    ReturnValue_t result = unmountSdCard(sdCard);
     if (result != returnvalue::OK) {
       return result;
     }
@@ -189,7 +184,7 @@ ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
   command << "q7hw sd set " << sdstring << " " << statestring;
   cmdExecutor.load(command.str(), blocking, printCmdOutput);
   ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != returnvalue::OK) {
+  if (result != returnvalue::OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
   }
   return result;
@@ -204,6 +199,7 @@ ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& sdStates) {
 ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
   using namespace std;
   if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
+    sif::warning << "SdCardManager::mountSdCard: Command still pending" << std::endl;
     return CommandExecutor::COMMAND_PENDING;
   }
   if (sdCard == sd::SdCard::BOTH) {

bsp_q7s/fs/SdCardManager.h

@@ -114,8 +114,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
    *           SYSTEM_CALL_ERROR on system error
    */
-  ReturnValue_t switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard = true,
-                                SdStatePair* statusPair = nullptr);
+  ReturnValue_t switchOffSdCard(sd::SdCard sdCard, SdStatePair& sdStates, bool doUnmountSdCard);
 
   /**
    * Get the state of the SD cards. If the state file does not exist, this function will

bsp_q7s/objectFactory.cpp

@@ -1,7 +1,9 @@
-#include "ObjectFactory.h"
+#include "objectFactory.h"
 
 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@@ -31,6 +33,9 @@
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/tcs/TmpDevFdir.h>
 
+#include <cstdint>
+#include <cstring>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
@@ -99,6 +104,7 @@
 
 #include <sstream>
 
+#include "bsp_q7s/core/defs.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
@@ -129,6 +135,11 @@ ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
 std::atomic_bool PTME_LOCKED = false;
 std::atomic_uint16_t I2C_FATAL_ERRORS = 0;
+uint8_t core::FW_VERSION_MAJOR = 0;
+uint8_t core::FW_VERSION_MINOR = 0;
+uint8_t core::FW_VERSION_REVISION = 0;
+bool core::FW_VERSION_HAS_SHA = false;
+char core::FW_VERSION_GIT_SHA[4] = {};
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
@@ -150,28 +161,23 @@ void Factory::setStaticFrameworkObjectIds() {
 
 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }
 
-void ObjectFactory::createTmpComponents() {
-  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
-      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
-      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
-      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
-      // damaged
-      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
-      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
-  }};
+void ObjectFactory::createTmpComponents(
+    std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd) {
+  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
+  if (core::FW_VERSION_MAJOR == 4) {
+    tmpI2cDev = q7s::I2C_PL_EIVE;
+  } else if (core::FW_VERSION_MAJOR >= 5) {
+    tmpI2cDev = q7s::I2C_Q7_EIVE;
+  }
   std::vector<I2cCookie*> tmpDevCookies;
 
-  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
+  for (size_t idx = 0; idx < tmpDevsToAdd.size(); idx++) {
     tmpDevCookies.push_back(
-        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
+        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, tmpI2cDev));
     auto* tmpDevHandler =
-        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[idx].first));
+        new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevsToAdd[idx].first));
     tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
-    // TODO: Remove this after TCS subsystem was added
-    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
-    // we set them to normal mode immediately here.
-    tmpDevHandler->setModeNormal();
   }
 }
 
@@ -243,7 +249,7 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
   createRadSensorChipSelect(gpioComIF);
 
   SpiCookie* spiCookieRadSensor =
-      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
+      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, radSens::READ_SIZE,
                     spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
   spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT);
   auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
@@ -505,7 +511,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 +736,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 +750,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);
@@ -908,8 +902,6 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
       new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                              gpioComIF, SdCardManager::instance(), stackHandler, false);
   spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
-//  plPcduHandler->enablePeriodicPrintout(true, 5);
-//  static_cast<void>(plPcduHandler);
 #if OBSW_TEST_PL_PCDU == 1
   plPcduHandler->setStartUpImmediately();
 #endif
@@ -943,16 +935,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTrackerCookie->setNoFixedSizeReply();
   StrComHandler* strComIF = new StrComHandler(objects::STR_COM_IF);
 
-  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
+  const char* paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
   if (paramJsonFile == nullptr) {
     sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
   }
@@ -965,12 +948,13 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   starTracker->setCustomFdir(strFdir);
 }
 
-void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets) {
+void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets,
+                                         const char* i2cDev) {
   auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
   imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
 
   new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
-  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, i2cDev);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                      power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
@@ -986,8 +970,8 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
 #endif
 }
 
-void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets, const char* i2cDev) {
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, i2cDev);
   BpxBatteryHandler* bpxHandler = new BpxBatteryHandler(
       objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie, enableHkSets);
   bpxHandler->setStartUpImmediately();
@@ -1025,3 +1009,50 @@ 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 (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
+    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);
+  }
+}
+
+ReturnValue_t ObjectFactory::readFirmwareVersion() {
+  uint32_t* mappedSysRomAddr = nullptr;
+  // The SYS ROM FPGA block is only available in those versions.
+  if (not(common::OBSW_VERSION_MAJOR >= 6) or (common::OBSW_VERSION_MAJOR == 4)) {
+    return returnvalue::OK;
+  }
+  // This has to come before the version announce because it might be required for retrieving
+  // the firmware version.
+  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
+  ReturnValue_t result =
+      sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
+  if (result != returnvalue::OK) {
+    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
+    return returnvalue::FAILED;
+  }
+  if (mappedSysRomAddr != nullptr) {
+    uint32_t firstEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr));
+    uint32_t secondEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr) + 1);
+    core::FW_VERSION_MAJOR = (firstEntry >> 24) & 0xff;
+    core::FW_VERSION_MINOR = (firstEntry >> 16) & 0xff;
+    core::FW_VERSION_REVISION = (firstEntry >> 8) & 0xff;
+    bool hasGitSha = (firstEntry & 0x0b1);
+    if (hasGitSha) {
+      std::memcpy(core::FW_VERSION_GIT_SHA, &secondEntry, 4);
+    }
+  }
+  return returnvalue::OK;
+}

bsp_q7s/objectFactory.h

@@ -58,7 +58,7 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
                           bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
-void createTmpComponents();
+void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd);
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
@@ -67,17 +67,19 @@ void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, Ser
                               adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
-void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
-void createBpxBatteryComponent(bool enableHkSets);
+void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
+void createBpxBatteryComponent(bool enableHkSets, const char* i2cDev);
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
 ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
+ReturnValue_t readFirmwareVersion();
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);
+void createPlI2cResetGpio(LinuxLibgpioIF* gpioComIF);
 
 void testAcsBrdAss(AcsBoardAssembly* assAss);
 

bsp_q7s/obsw.cpp

@@ -11,13 +11,13 @@
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/WatchdogHandler.h"
 #include "commonConfig.h"
-#include "core/scheduling.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/version.h"
 #include "mission/acs/defs.h"
 #include "mission/com/defs.h"
 #include "mission/system/systemTree.h"
 #include "q7sConfig.h"
+#include "scheduling.h"
 #include "watchdog/definitions.h"
 
 static constexpr int OBSW_ALREADY_RUNNING = -2;

bsp_q7s/scheduling.cpp

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/core/ObjectFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/platform.h"
@@ -21,6 +20,8 @@
 #include "mission/pollingSeqTables.h"
 #include "mission/scheduling.h"
 #include "mission/utility/InitMission.h"
+#include "objectFactory.h"
+#include "q7sConfig.h"
 
 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
@@ -156,6 +157,10 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
   }
+  result = genericSysTask->addComponent(objects::EPS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("EPS_SUBSYSTEM", objects::EPS_SUBSYSTEM);
+  }
   result = genericSysTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
@@ -324,6 +329,10 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
   }
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 
 #if OBSW_ADD_SYRLINKS == 1
   PeriodicTaskIF* syrlinksCom = factory->createPeriodicTask(
@@ -527,7 +536,15 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
   FixedTimeslotTaskIF* i2cPst =
       factory.createFixedTimeslotTask("I2C_PS_PST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.6,
                                       missedDeadlineFunc, &RR_SCHEDULING);
-  result = pst::pstI2cProcessingSystem(i2cPst);
+  pst::TmpSchedConfig tmpSchedConf;
+#if OBSW_Q7S_EM == 1
+  tmpSchedConf.scheduleTmpDev0 = true;
+  tmpSchedConf.scheduleTmpDev1 = true;
+  tmpSchedConf.schedulePlPcduDev0 = true;
+  tmpSchedConf.schedulePlPcduDev1 = true;
+  tmpSchedConf.scheduleIfBoardDev = true;
+#endif
+  result = pst::pstI2c(tmpSchedConf, i2cPst);
   if (result != returnvalue::OK) {
     if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;

bsp_q7s/xadc/Xadc.cpp

@@ -129,7 +129,7 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
     sif::warning << "Xadc::readValFromFile: Failed to open file " << filename << std::endl;
     return returnvalue::FAILED;
   }
-  char valstring[MAX_STR_LENGTH] = "";
+  char valstring[MAX_STR_LENGTH]{};
   char* returnVal = fgets(valstring, MAX_STR_LENGTH, fp);
   if (returnVal == nullptr) {
     sif::warning << "Xadc::readValFromFile: Failed to read string from file " << filename
@@ -139,6 +139,11 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
   }
   std::istringstream valSstream(valstring);
   valSstream >> val;
+  if (valSstream.bad()) {
+    sif::warning << "Xadc: Conversion of value to target type failed" << std::endl;
+    fclose(fp);
+    return returnvalue::FAILED;
+  }
   fclose(fp);
   return returnvalue::OK;
 }

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,

common/config/eive/definitions.h

@@ -11,6 +11,8 @@ static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
 static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
 static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
 static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
+static constexpr char PUS_SEQUENCE_COUNT_FILE[] = "pus-sequence-count.txt";
+static constexpr char CFDP_SEQUENCE_COUNT_FILE[] = "cfdp-sequence-count.txt";
 
 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
@@ -77,6 +79,7 @@ static constexpr uint32_t SCHED_BLOCK_RTD = 150;
 static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300;
 static constexpr uint32_t SCHED_BLOCK_8_PLPCDU_MS = 320;
 static constexpr uint32_t SCHED_BLOCK_9_RAD_SENS_MS = 340;
+static constexpr uint32_t SCHED_BLOCK_10_PWR_CTRL_MS = 350;
 
 // 15 ms for FM
 static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SUS_READ_MS) / 400.0;
@@ -92,6 +95,8 @@ static constexpr float SCHED_BLOCK_RTD_PERIOD = static_cast<float>(SCHED_BLOCK_R
 static constexpr float SCHED_BLOCK_7_PERIOD = static_cast<float>(SCHED_BLOCK_7_RW_READ_MS) / 400.0;
 static constexpr float SCHED_BLOCK_8_PERIOD = static_cast<float>(SCHED_BLOCK_8_PLPCDU_MS) / 400.0;
 static constexpr float SCHED_BLOCK_9_PERIOD = static_cast<float>(SCHED_BLOCK_9_RAD_SENS_MS) / 400.0;
+static constexpr float SCHED_BLOCK_10_PERIOD =
+    static_cast<float>(SCHED_BLOCK_10_PWR_CTRL_MS) / 400.0;
 
 }  // namespace spiSched
 

common/config/eive/eventSubsystemIds.h

@@ -40,6 +40,7 @@ enum : uint8_t {
   COM_SUBSYSTEM = 142,
   PERSISTENT_TM_STORE = 143,
   SYRLINKS_COM = 144,
+  SUS_HANDLER = 145,
   COMMON_SUBSYSTEM_ID_END
 
 };

common/config/eive/objects.h

@@ -26,6 +26,7 @@ enum commonObjects : uint32_t {
   THERMAL_CONTROLLER = 0x43400001,
   ACS_CONTROLLER = 0x43000002,
   CORE_CONTROLLER = 0x43000003,
+  POWER_CONTROLLER = 0x43000004,
   GLOBAL_JSON_CFG = 0x43000006,
 
   /* 0x44 ('D') for device handlers */
@@ -157,6 +158,7 @@ enum commonObjects : uint32_t {
   PL_SUBSYSTEM = 0x73010002,
   TCS_SUBSYSTEM = 0x73010003,
   COM_SUBSYSTEM = 0x73010004,
+  EPS_SUBSYSTEM = 0x73010005,
 
   TM_FUNNEL = 0x73000100,
   PUS_TM_FUNNEL = 0x73000101,

dummies/CMakeLists.txt

@@ -19,6 +19,7 @@ target_sources(
          GpsCtrlDummy.cpp
          GyroAdisDummy.cpp
          GyroL3GD20Dummy.cpp
+         RadSensorDummy.cpp
          MgmLIS3MDLDummy.cpp
          PlPcduDummy.cpp
          ExecutableComIfDummy.cpp

dummies/CoreControllerDummy.cpp

@@ -1,6 +1,6 @@
 #include "CoreControllerDummy.h"
 
-#include <bsp_q7s/core/CoreDefinitions.h>
+#include <bsp_q7s/core/defs.h>
 #include <objects/systemObjectList.h>
 
 #include <cmath>

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/Max31865Dummy.cpp

@@ -7,15 +7,21 @@ using namespace returnvalue;
 Max31865Dummy::Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), set(this, EiveMax31855::EXCHANGE_SET_ID) {}
 void Max31865Dummy::doStartUp() { setMode(MODE_ON); }
-void Max31865Dummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
+void Max31865Dummy::doShutDown() {
+  PoolReadGuard pg(&set);
+  set.setValidity(false, true);
+  setMode(MODE_OFF);
+}
 ReturnValue_t Max31865Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
-ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
+ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
 ReturnValue_t Max31865Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                      const uint8_t *commandData,
                                                      size_t commandDataLen) {
-  return 0;
+  return NOTHING_TO_SEND;
 }
 ReturnValue_t Max31865Dummy::scanForReply(const uint8_t *start, size_t len,
                                           DeviceCommandId_t *foundId, size_t *foundLen) {

dummies/PlPcduDummy.cpp

@@ -7,7 +7,7 @@ PlPcduDummy::PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comC
 
 PlPcduDummy::~PlPcduDummy() {}
 
-void PlPcduDummy::doStartUp() { setMode(MODE_NORMAL); }
+void PlPcduDummy::doStartUp() { setMode(MODE_ON); }
 
 void PlPcduDummy::doShutDown() { setMode(MODE_OFF); }
 
@@ -43,3 +43,16 @@ ReturnValue_t PlPcduDummy::initializeLocalDataPool(localpool::DataPool &localDat
   localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}, true));
   return returnvalue::OK;
 }
+
+ReturnValue_t PlPcduDummy::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                            uint32_t *msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}

dummies/PlPcduDummy.h

@@ -1,7 +1,9 @@
 #ifndef DUMMIES_PLPCDUDUMMY_H_
 #define DUMMIES_PLPCDUDUMMY_H_
 
+#include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include <mission/payload/payloadPcduDefinitions.h>
 
 class PlPcduDummy : public DeviceHandlerBase {
@@ -29,6 +31,10 @@ class PlPcduDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t *msToReachTheMode) override;
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
 };
 
 #endif /* DUMMIES_PLPCDUDUMMY_H_ */

dummies/PlocMpsocDummy.cpp

@@ -23,6 +23,19 @@ ReturnValue_t PlocMpsocDummy::buildCommandFromCommand(DeviceCommandId_t deviceCo
   return returnvalue::OK;
 }
 
+ReturnValue_t PlocMpsocDummy::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                               uint32_t *msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}
+
 ReturnValue_t PlocMpsocDummy::scanForReply(const uint8_t *start, size_t len,
                                            DeviceCommandId_t *foundId, size_t *foundLen) {
   return returnvalue::OK;

dummies/PlocMpsocDummy.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
 #include "mission/power/defs.h"
 
@@ -24,6 +26,9 @@ class PlocMpsocDummy : public DeviceHandlerBase {
                                         size_t commandDataLen) override;
   ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                              size_t *foundLen) override;
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t *msToReachTheMode) override;
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void fillCommandAndReplyMap() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;

dummies/PlocSupervisorDummy.cpp

@@ -51,3 +51,17 @@ ReturnValue_t PlocSupervisorDummy::getSwitches(const uint8_t **switches,
   *switches = reinterpret_cast<const uint8_t *>(&switchId);
   return returnvalue::OK;
 }
+
+ReturnValue_t PlocSupervisorDummy::checkModeCommand(Mode_t commandedMode,
+                                                    Submode_t commandedSubmode,
+                                                    uint32_t *msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}

dummies/PlocSupervisorDummy.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include <mission/power/defs.h>
 
 class PlocSupervisorDummy : public DeviceHandlerBase {
@@ -32,4 +34,7 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
   ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t *msToReachTheMode) override;
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
 };

dummies/RadSensorDummy.cpp

@@ -0,0 +1,55 @@
+#include "RadSensorDummy.h"
+
+RadSensorDummy::RadSensorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie), sensorSet(this) {}
+
+RadSensorDummy::~RadSensorDummy() {}
+
+void RadSensorDummy::doStartUp() { setMode(MODE_ON); }
+
+void RadSensorDummy::doShutDown() { setMode(MODE_OFF); }
+
+ReturnValue_t RadSensorDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t RadSensorDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t RadSensorDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                      const uint8_t *commandData,
+                                                      size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t RadSensorDummy::scanForReply(const uint8_t *start, size_t len,
+                                           DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t RadSensorDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void RadSensorDummy::fillCommandAndReplyMap() {}
+
+uint32_t RadSensorDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t RadSensorDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                      LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(radSens::TEMPERATURE_C, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(radSens::AIN0, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(radSens::AIN1, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(radSens::AIN4, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(radSens::AIN5, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(radSens::AIN6, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(radSens::AIN7, new PoolEntry<uint16_t>({0}));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(sensorSet.getSid(), false, 20.0));
+  return returnvalue::OK;
+
+  return returnvalue::OK;
+}
+
+LocalPoolDataSetBase *RadSensorDummy::getDataSetHandle(sid_t sid) { return &sensorSet; }

dummies/RadSensorDummy.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+#include "mission/payload/radSensorDefinitions.h"
+
+class RadSensorDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  RadSensorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~RadSensorDummy();
+
+ protected:
+  radSens::RadSensorDataset sensorSet;
+
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) 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,29 @@ 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;
 }
+
+LocalPoolDataSetBase *RwDummy::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case (rws::SetIds::STATUS_SET_ID): {
+      return &statusSet;
+    }
+    case (rws::SetIds::LAST_RESET_ID): {
+      return &lastResetStatusSet;
+    }
+    case (rws::SetIds::SPEED_CMD_SET): {
+      return &rwSpeedActuationSet;
+    }
+    case (rws::SetIds::TM_SET_ID): {
+      return &tmDataset;
+    }
+  }
+  return nullptr;
+}

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});
 
@@ -31,6 +37,7 @@ class RwDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 };
 
 #endif /* DUMMIES_RWDUMMY_H_ */

dummies/SusDummy.cpp

@@ -5,7 +5,7 @@ SusDummy::SusDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
 
 SusDummy::~SusDummy() {}
 
-void SusDummy::doStartUp() { setMode(MODE_NORMAL); }
+void SusDummy::doStartUp() { setMode(MODE_ON); }
 
 void SusDummy::doShutDown() { setMode(MODE_OFF); }
 

dummies/TemperatureSensorInserter.cpp

@@ -7,9 +7,9 @@
 #include <cstdlib>
 #include <utility>
 
-TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
-                                                     Max31865DummyMap tempSensorDummies_,
-                                                     Tmp1075DummyMap tempTmpSensorDummies_)
+TemperatureSensorInserter::TemperatureSensorInserter(
+    object_id_t objectId, Max31865DummyMap tempSensorDummies_,
+    std::optional<Tmp1075DummyMap> tempTmpSensorDummies_)
     : SystemObject(objectId),
       max31865DummyMap(std::move(tempSensorDummies_)),
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
@@ -25,8 +25,10 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
     for (auto& rtdDummy : max31865DummyMap) {
       rtdDummy.second->setTemperature(10, true);
     }
-    for (auto& tmpDummy : tmp1075DummyMap) {
-      tmpDummy.second->setTemperature(10, true);
+    if (tmp1075DummyMap.has_value()) {
+      for (auto& tmpDummy : tmp1075DummyMap.value()) {
+        tmpDummy.second->setTemperature(10, true);
+      }
     }
     tempsWereInitialized = true;
   }
@@ -96,6 +98,25 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
       }
       break;
     }
+    case (TestCase::COLD_PLOC_CONSECUTIVE): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting warmer PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
+      }
+      if (cycles == 45) {
+        sif::debug << "Setting cold PLOC temperature again" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
+      }
+      if (cycles == 60) {
+        sif::debug << "Setting warmer PLOC temperature again" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
+      }
+      break;
+    }
     case (TestCase::COLD_CAMERA): {
       if (cycles == 15) {
         sif::debug << "Setting cold CAM temperature" << std::endl;
@@ -105,6 +126,21 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
         sif::debug << "Setting CAM temperature back to normal" << std::endl;
         max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(0, true);
       }
+      break;
+    }
+    case (TestCase::COLD_PLOC_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-40, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_CAMERA_STAYS_COLD): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-40, true);
+      }
+      break;
     }
   }
   cycles++;

dummies/TemperatureSensorInserter.h

@@ -12,7 +12,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
   using Max31865DummyMap = std::map<object_id_t, Max31865Dummy*>;
   using Tmp1075DummyMap = std::map<object_id_t, Tmp1075Dummy*>;
   explicit TemperatureSensorInserter(object_id_t objectId, Max31865DummyMap tempSensorDummies_,
-                                     Tmp1075DummyMap tempTmpSensorDummies_);
+                                     std::optional<Tmp1075DummyMap> tempTmpSensorDummies_);
 
   ReturnValue_t initialize() override;
   ReturnValue_t initializeAfterTaskCreation() override;
@@ -22,7 +22,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
 
  private:
   Max31865DummyMap max31865DummyMap;
-  Tmp1075DummyMap tmp1075DummyMap;
+  std::optional<Tmp1075DummyMap> tmp1075DummyMap;
 
   enum TestCase {
     NONE = 0,
@@ -32,6 +32,9 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
     COLD_STR = 4,
     COLD_STR_CONSECUTIVE = 5,
     COLD_CAMERA = 6,
+    COLD_PLOC_CONSECUTIVE = 7,
+    COLD_PLOC_STAYS_COLD = 8,
+    COLD_CAMERA_STAYS_COLD = 9
   };
   int iteration = 0;
   uint32_t cycles = 0;

dummies/Tmp1075Dummy.cpp

@@ -8,35 +8,57 @@ using namespace returnvalue;
 Tmp1075Dummy::Tmp1075Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie), set(this) {}
 
-void Tmp1075Dummy::doStartUp() { setMode(MODE_NORMAL); }
-void Tmp1075Dummy::doShutDown() { setMode(MODE_OFF); }
+void Tmp1075Dummy::doStartUp() { setMode(MODE_ON); }
+void Tmp1075Dummy::doShutDown() {
+  PoolReadGuard pg(&set);
+  set.setValidity(false, true);
+  setMode(MODE_OFF);
+}
 
 ReturnValue_t Tmp1075Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
 }
-ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
+
+ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
 ReturnValue_t Tmp1075Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                     const uint8_t *commandData,
                                                     size_t commandDataLen) {
-  return 0;
+  return NOTHING_TO_SEND;
 }
+
 ReturnValue_t Tmp1075Dummy::scanForReply(const uint8_t *start, size_t len,
                                          DeviceCommandId_t *foundId, size_t *foundLen) {
   return 0;
 }
+
 ReturnValue_t Tmp1075Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   return 0;
 }
+
 void Tmp1075Dummy::setTemperature(float temperature, bool valid) {
   PoolReadGuard pg(&set);
   set.temperatureCelcius.value = temperature;
   set.setValidity(valid, true);
 }
+
 void Tmp1075Dummy::fillCommandAndReplyMap() {}
+
 uint32_t Tmp1075Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 1000; }
+
 ReturnValue_t Tmp1075Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                     LocalDataPoolManager &poolManager) {
   localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075, new PoolEntry<float>({10.0}, true));
   return OK;
 }
+
+ReturnValue_t Tmp1075Dummy::setHealth(HealthState health) {
+  if (health == FAULTY or health == PERMANENT_FAULTY) {
+    setMode(_MODE_SHUT_DOWN);
+  }
+  return DeviceHandlerBase::setHealth(health);
+}
+
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Tmp1075Dummy.h

@@ -26,6 +26,7 @@ class Tmp1075Dummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  ReturnValue_t setHealth(HealthState health) override;
 
  protected:
   LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;

dummies/helperFactory.cpp

@@ -18,6 +18,7 @@
 #include <dummies/PlPcduDummy.h>
 #include <dummies/PlocMpsocDummy.h>
 #include <dummies/PlocSupervisorDummy.h>
+#include <dummies/RadSensorDummy.h>
 #include <dummies/RwDummy.h>
 #include <dummies/SaDeploymentDummy.h>
 #include <dummies/ScexDummy.h>
@@ -34,6 +35,7 @@
 
 #include "TemperatureSensorInserter.h"
 #include "dummies/Max31865Dummy.h"
+#include "dummies/SusDummy.h"
 #include "dummies/Tmp1075Dummy.h"
 #include "mission/genericFactory.h"
 #include "mission/system/acs/acsModeTree.h"
@@ -63,11 +65,14 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
   ObjectFactory::createRwAssy(pwrSwitcher, power::Switches::PDU2_CH2_RW_5V, rws, rwIds);
   new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
-  auto* strAssy = new StrAssembly(objects::STR_ASSY);
-  strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
-  auto* strDummy =
-      new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
-  strDummy->connectModeTreeParent(*strAssy);
+
+  if (cfg.addStrDummy) {
+    auto* strAssy = new StrAssembly(objects::STR_ASSY);
+    strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+    auto* strDummy =
+        new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+    strDummy->connectModeTreeParent(*strAssy);
+  }
   if (cfg.addSyrlinksDummies) {
     auto* syrlinksDummy =
         new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@@ -191,25 +196,36 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
         objects::RTD_15_IC18_IMTQ,
         new Max31865Dummy(objects::RTD_15_IC18_IMTQ, objects::DUMMY_COM_IF, comCookieDummy));
 
-    std::map<object_id_t, Tmp1075Dummy*> tmpSensorDummies;
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_TCS_0,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_TCS_1,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_PLPCDU_0,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
-    // damaged.
-    //        tmpSensorDummies.emplace(
-    //            objects::TMP1075_HANDLER_PLPCDU_1,
-    //            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF,
-    //            comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_IF_BOARD,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
-
+    std::optional<TemperatureSensorInserter::Tmp1075DummyMap> tmpSensorDummies;
+    if (cfg.addTmpDummies) {
+      TemperatureSensorInserter::Tmp1075DummyMap tmpDummyMap;
+      if (cfg.tmp1075Cfg.addTcsBrd0) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_0,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF,
+                                             comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addTcsBrd1) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_1,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF,
+                                             comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addPlPcdu0) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_0,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addPlPcdu1) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_1,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      if (cfg.tmp1075Cfg.addIfBrd) {
+        tmpDummyMap.emplace(objects::TMP1075_HANDLER_IF_BOARD,
+                            new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD,
+                                             objects::DUMMY_COM_IF, comCookieDummy));
+      }
+      tmpSensorDummies = std::move(tmpDummyMap);
+    }
     new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
                                   tmpSensorDummies);
     TcsBoardAssembly* tcsBoardAssy =
@@ -217,8 +233,10 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     for (auto& rtd : rtdSensorDummies) {
       rtd.second->connectModeTreeParent(*tcsBoardAssy);
     }
-    for (auto& tmp : tmpSensorDummies) {
-      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    if (tmpSensorDummies.has_value()) {
+      for (auto& tmp : tmpSensorDummies.value()) {
+        tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+      }
     }
   }
   if (cfg.addCamSwitcherDummy) {
@@ -226,11 +244,15 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
                                         power::Switches::PDU2_CH8_PAYLOAD_CAMERA);
     camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   }
-  auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
-  scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
-  auto* plPcduDummy =
-      new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  plPcduDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
+  if (cfg.addScexDummy) {
+    auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
+    scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
+  }
+  if (cfg.addPlPcduDummy) {
+    auto* plPcduDummy =
+        new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    plPcduDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
+  }
   if (cfg.addPlocDummies) {
     auto* plocMpsocDummy =
         new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@@ -239,4 +261,9 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
         objects::PLOC_SUPERVISOR_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, pwrSwitcher);
     plocSupervisorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   }
+  if (cfg.addRadSensorDummy) {
+    auto* radSensorDummy =
+        new RadSensorDummy(objects::RAD_SENSOR, objects::DUMMY_COM_IF, comCookieDummy);
+    radSensorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
+  }
 }

dummies/helperFactory.h

@@ -6,6 +6,14 @@ class GpioIF;
 
 namespace dummy {
 
+struct Tmp1075Cfg {
+  bool addTcsBrd0 = true;
+  bool addTcsBrd1 = true;
+  bool addPlPcdu0 = true;
+  bool addPlPcdu1 = true;
+  bool addIfBrd = true;
+};
+
 // Default values targeted towards EM.
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
@@ -19,7 +27,13 @@ struct DummyCfg {
   bool addTempSensorDummies = true;
   bool addRtdComIFDummy = true;
   bool addPlocDummies = true;
+  bool addStrDummy = true;
+  bool addTmpDummies = true;
+  bool addRadSensorDummy = true;
+  bool addPlPcduDummy = false;
+  Tmp1075Cfg tmp1075Cfg;
   bool addCamSwitcherDummy = false;
+  bool addScexDummy = false;
 };
 
 void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF, bool enableHkSets);

generators/bsp_hosted_events.csv

@@ -94,10 +94,16 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11205;0x2bc5;MEKF_AUTOMATIC_RESET;INFO;MEKF performed an automatic reset after detection of nonfinite values.;mission/acs/defs.h
 11206;0x2bc6;MEKF_INVALID_MODE_VIOLATION;HIGH;MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
+11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
+11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
+11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
+11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
+11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
+11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@@ -121,6 +127,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -133,6 +141,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
+11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
 12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
 12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
 12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
@@ -160,6 +169,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12412;0x307c;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/pdec.h
 12413;0x307d;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/pdec.h
 12414;0x307e;PDEC_INIT_FAILED;HIGH;PDEC initialization failed. This might also be due to the persistent confiuration never becoming available, for example due to SD card issues.;linux/ipcore/pdec.h
+12415;0x307f;PDEC_CONFIG_CORRUPTED;HIGH;The PDEC configuration area has been corrupted P1: The first configuration word P2: The second configuration word;linux/ipcore/pdec.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/acs/StrComHandler.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/acs/StrComHandler.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/acs/StrComHandler.h
@@ -254,6 +264,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13800;0x35e8;MISSING_PACKET;LOW;No description;mission/payload/scexHelpers.h
 13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;No description;mission/payload/scexHelpers.h
 13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;No description;mission/payload/scexHelpers.h
+13803;0x35eb;FS_UNUSABLE;LOW;No description;mission/payload/scexHelpers.h
 13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
@@ -271,6 +282,8 @@ 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
+14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;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
@@ -279,6 +292,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
@@ -294,3 +310,5 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
+14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values again, resetting invalid message counter. P1: Invalid message counter.;mission/acs/SusHandler.h

generators/bsp_hosted_objects.csv

@@ -1,6 +1,7 @@
 0x42694269;TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
+0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
 0x43400001;THERMAL_CONTROLLER
 0x44000001;DUMMY_HANDLER
@@ -156,6 +157,7 @@
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE

generators/bsp_hosted_returnvalues.csv

@@ -210,6 +210,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h

generators/bsp_hosted_subsystems.csv

@@ -60,3 +60,4 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
+145;SUS_HANDLER

generators/bsp_q7s_events.csv

@@ -94,10 +94,16 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11205;0x2bc5;MEKF_AUTOMATIC_RESET;INFO;MEKF performed an automatic reset after detection of nonfinite values.;mission/acs/defs.h
 11206;0x2bc6;MEKF_INVALID_MODE_VIOLATION;HIGH;MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
+11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
+11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
+11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
+11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
+11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
+11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@@ -121,6 +127,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -133,6 +141,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
+11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
 12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
 12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
 12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
@@ -160,6 +169,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12412;0x307c;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/pdec.h
 12413;0x307d;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/pdec.h
 12414;0x307e;PDEC_INIT_FAILED;HIGH;PDEC initialization failed. This might also be due to the persistent confiuration never becoming available, for example due to SD card issues.;linux/ipcore/pdec.h
+12415;0x307f;PDEC_CONFIG_CORRUPTED;HIGH;The PDEC configuration area has been corrupted P1: The first configuration word P2: The second configuration word;linux/ipcore/pdec.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/acs/StrComHandler.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/acs/StrComHandler.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/acs/StrComHandler.h
@@ -254,6 +264,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13800;0x35e8;MISSING_PACKET;LOW;No description;mission/payload/scexHelpers.h
 13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;No description;mission/payload/scexHelpers.h
 13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;No description;mission/payload/scexHelpers.h
+13803;0x35eb;FS_UNUSABLE;LOW;No description;mission/payload/scexHelpers.h
 13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
@@ -271,6 +282,8 @@ 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
+14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;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
@@ -279,6 +292,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
+14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
@@ -294,3 +310,5 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
+14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values again, resetting invalid message counter. P1: Invalid message counter.;mission/acs/SusHandler.h

generators/bsp_q7s_objects.csv

@@ -1,6 +1,7 @@
 0x00005060;P60DOCK_TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
+0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
@@ -161,6 +162,7 @@
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
+0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE

generators/bsp_q7s_returnvalues.csv

@@ -210,6 +210,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h

generators/bsp_q7s_subsystems.csv

@@ -60,3 +60,4 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
+145;SUS_HANDLER

generators/events/event_parser.py

@@ -54,9 +54,13 @@ class BspConfig:
 
         # Store this file in the root of the generators folder
         self.csv_filename = Path(f"{ROOT_DIR}/{self.bsp_dir_name}_events.csv")
-        self.subsystems_csv_filename = Path(f"{ROOT_DIR}/{self.bsp_dir_name}_subsystems.csv")
+        self.subsystems_csv_filename = Path(
+            f"{ROOT_DIR}/{self.bsp_dir_name}_subsystems.csv"
+        )
         self.csv_copy_dest = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/events.csv")
-        self.subsystem_csv_copy_dest = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/subsystems.csv")
+        self.subsystem_csv_copy_dest = Path(
+            f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/subsystems.csv"
+        )
 
         if (
             self.bsp_select == BspType.BSP_Q7S

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 295 translations.
+ * @brief    Auto-generated event translation file. Contains 313 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateEvents.h"
 
@@ -100,10 +100,16 @@ const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
 const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +133,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +147,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -166,6 +175,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -260,6 +270,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -277,6 +288,8 @@ 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 *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_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";
@@ -285,6 +298,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -300,6 +316,8 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -493,6 +511,8 @@ const char *translateEvents(Event event) {
       return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -501,6 +521,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -547,6 +577,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -571,6 +605,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -625,6 +661,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -813,6 +851,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -847,6 +887,10 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -863,6 +907,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -893,6 +943,10 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/translateObjects.cpp

@@ -1,14 +1,15 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 175 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Contains 177 translations.
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateObjects.h"
 
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
@@ -169,6 +170,7 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -190,6 +192,8 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
     case 0x43400001:
@@ -510,6 +514,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

linux/ObjectFactory.cpp

@@ -13,6 +13,7 @@
 #include <linux/tcs/Max31865RtdPolling.h>
 #include <mission/acs/SusHandler.h>
 #include <mission/controller/AcsController.h>
+#include <mission/controller/PowerController.h>
 #include <mission/genericFactory.h>
 #include <mission/payload/ScexDeviceHandler.h>
 #include <mission/system/acs/SusAssembly.h>
@@ -27,6 +28,7 @@
 #include "devices/gpioIds.h"
 #include "eive/definitions.h"
 #include "mission/system/acs/acsModeTree.h"
+#include "mission/system/power/epsModeTree.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "mission/tcs/defs.h"
@@ -337,6 +339,14 @@ AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool en
   return acsCtrl;
 }
 
+PowerController* ObjectFactory::createPowerController(bool connectSubsystem, bool enableHkSets) {
+  auto pwrCtrl = new PowerController(objects::POWER_CONTROLLER, enableHkSets);
+  if (connectSubsystem) {
+    pwrCtrl->connectModeTreeParent(satsystem::eps::EPS_SUBSYSTEM);
+  }
+  return pwrCtrl;
+}
+
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != returnvalue::OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;

linux/ObjectFactory.h

@@ -16,6 +16,7 @@ class GpioIF;
 class SpiComIF;
 class PowerSwitchIF;
 class AcsController;
+class PowerController;
 
 namespace ObjectFactory {
 
@@ -31,5 +32,6 @@ void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
 void gpioChecker(ReturnValue_t result, std::string output);
 
 AcsController* createAcsController(bool connectSubsystem, bool enableHkSets);
+PowerController* createPowerController(bool connectSubsystem, bool enableHkSets);
 
 }  // namespace ObjectFactory

linux/acs/AcsBoardPolling.cpp

@@ -767,6 +767,9 @@ void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
         mgm.replyResult = result;
         return;
       }
+      // For some reason, bit 1 is sometimes set on the reply, even if it is not set for the
+      // command.. Ignore it for now by clearing it.
+      rawReply[1] &= ~(1 << 1);
       if (rawReply[1] != mgmRm3100::CMM_VALUE) {
         sif::error << "AcsBoardPolling: MGM RM3100 read back CMM invalid" << std::endl;
         mgm.replyResult = result;

linux/acs/GpsHyperionLinuxController.cpp

@@ -21,6 +21,7 @@ GpsHyperionLinuxController::GpsHyperionLinuxController(object_id_t objectId, obj
                                                        bool enableHkSets, bool debugHyperionGps)
     : ExtendedControllerBase(objectId),
       gpsSet(this),
+      skyviewSet(this),
       enableHkSets(enableHkSets),
       debugHyperionGps(debugHyperionGps) {}
 
@@ -29,7 +30,17 @@ GpsHyperionLinuxController::~GpsHyperionLinuxController() {
   gps_close(&gps);
 }
 
-LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) { return &gpsSet; }
+LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) {
+  switch (sid.ownerSetId) {
+    case GpsHyperion::CORE_DATASET:
+      return &gpsSet;
+    case GpsHyperion::SKYVIEW_DATASET:
+      return &skyviewSet;
+    default:
+      return nullptr;
+  }
+  return nullptr;
+}
 
 ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                            uint32_t *msToReachTheMode) {
@@ -90,6 +101,13 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
   poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
+  localDataPoolMap.emplace(GpsHyperion::SKYVIEW_UNIX_SECONDS, new PoolEntry<double>());
+  localDataPoolMap.emplace(GpsHyperion::PRN_ID, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::AZIMUTH, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::ELEVATION, new PoolEntry<int16_t>());
+  localDataPoolMap.emplace(GpsHyperion::SIGNAL2NOISE, new PoolEntry<double>());
+  localDataPoolMap.emplace(GpsHyperion::USED, new PoolEntry<uint8_t>());
+  poolManager.subscribeForRegularPeriodicPacket({skyviewSet.getSid(), false, 120.0});
   return returnvalue::OK;
 }
 
@@ -166,30 +184,32 @@ bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
   if (mode == MODE_OFF) {
     return false;
   }
+  unsigned int readIdx = 0;
   if (readMode == ReadModes::SOCKET) {
     // Poll the GPS.
-    if (gps_waiting(&gps, 0)) {
-      if (-1 == gps_read(&gps)) {
+    while (gps_waiting(&gps, 0)) {
+      int retval = gps_read(&gps);
+      if (retval < 0) {
         readError();
         return false;
       }
-      oneShotSwitches.gpsReadFailedSwitch = true;
-      ReturnValue_t result = handleGpsReadData();
-      if (result == returnvalue::OK) {
-        return true;
-      } else {
-        return false;
+      readIdx++;
+      if (readIdx >= 40) {
+        sif::warning << "GpsHyperionLinuxController: Received " << readIdx
+                     << " GPSD message consecutively" << std::endl;
+        break;
       }
-      noModeSetCntr = 0;
-    } else {
-      return false;
+    }
+    if (readIdx > 0) {
+      oneShotSwitches.gpsReadFailedSwitch = true;
+      handleGpsReadData();
     }
   } else if (readMode == ReadModes::SHM) {
     sif::error << "GpsHyperionLinuxController::readGpsDataFromGpsdPermanentLoop: "
                   "SHM read not implemented"
                << std::endl;
   }
-  return true;
+  return false;
 }
 
 ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
@@ -208,7 +228,15 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
       return returnvalue::FAILED;
     }
   }
+  ReturnValue_t result = handleCoreTelemetry(modeIsSet);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleSkyviewTelemetry();
+  return result;
+}
 
+ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
   PoolReadGuard pg(&gpsSet);
   if (pg.getReadResult() != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
@@ -236,7 +264,9 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
     }
   }
   if (gpsSet.fixMode.value != newFix) {
+#if OBSW_Q7S_EM != 1
     triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, newFix);
+#endif
   }
   gpsSet.fixMode = newFix;
   gpsSet.fixMode.setValid(modeIsSet);
@@ -369,6 +399,22 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   return returnvalue::OK;
 }
 
+ReturnValue_t GpsHyperionLinuxController::handleSkyviewTelemetry() {
+  PoolReadGuard pg(&skyviewSet);
+  if (pg.getReadResult() != returnvalue::OK) {
+    return returnvalue::FAILED;
+  }
+  skyviewSet.unixSeconds.value = gps.skyview_time;
+  for (int sat = 0; sat < GpsHyperion::MAX_SATELLITES; sat++) {
+    skyviewSet.prn_id.value[sat] = gps.skyview[sat].PRN;
+    skyviewSet.azimuth.value[sat] = gps.skyview[sat].azimuth;
+    skyviewSet.elevation.value[sat] = gps.skyview[sat].elevation;
+    skyviewSet.signal2noise.value[sat] = gps.skyview[sat].ss;
+    skyviewSet.used.value[sat] = gps.skyview[sat].used;
+  }
+  return returnvalue::OK;
+}
+
 void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool validFix) {
   if (not timeInit and validFix) {
     if (not utility::timeSanityCheck()) {

linux/acs/GpsHyperionLinuxController.h

@@ -54,9 +54,12 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
                                         LocalDataPoolManager& poolManager) override;
 
   ReturnValue_t handleGpsReadData();
+  ReturnValue_t handleCoreTelemetry(bool modeIsSet);
+  ReturnValue_t handleSkyviewTelemetry();
 
  private:
   GpsPrimaryDataset gpsSet;
+  SkyviewDataset skyviewSet;
   gps_data_t gps = {};
   bool enableHkSets = false;
   const char* currentClientBuf = nullptr;
@@ -81,7 +84,6 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   } oneShotSwitches;
 
   bool debugHyperionGps = false;
-  int32_t noModeSetCntr = 0;
 
   // Returns true if the function should be called again or false if other
   // controller handling can be done.

linux/acs/StrComHandler.cpp

@@ -2,6 +2,7 @@
 
 #include <fcntl.h>
 #include <fsfw/filesystem/HasFileSystemIF.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/strHelpers.h>
@@ -23,6 +24,8 @@ extern "C" {
 
 using namespace returnvalue;
 
+static constexpr bool PACKET_WIRETAPPING = false;
+
 StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
   lock = MutexFactory::instance()->createMutex();
   semaphore.acquire();
@@ -52,7 +55,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
       case InternalState::POLL_ONE_REPLY: {
         // Stopwatch watch;
         replyTimeout.setTimeout(200);
-        replyResult = readOneReply(static_cast<uint32_t>(state));
+        readOneReply(static_cast<uint32_t>(state));
         {
           MutexGuard mg(lock);
           replyWasReceived = true;
@@ -680,6 +683,10 @@ ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendDa
   const uint8_t* txFrame;
   size_t frameLen;
   datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
+  if (PACKET_WIRETAPPING) {
+    sif::debug << "Sending STR frame" << std::endl;
+    arrayprinter::print(txFrame, frameLen);
+  }
   ssize_t bytesWritten = write(serialPort, txFrame, frameLen);
   if (bytesWritten != static_cast<ssize_t>(frameLen)) {
     sif::warning << "StrComHandler: Sending packet failed" << std::endl;
@@ -709,13 +716,11 @@ ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requ
 }
 
 ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
-  // Consider it a configuration error if the task is not done with a command -> reply cycle
-  // in time.
   bool replyWasReceived = false;
   {
     MutexGuard mg(lock);
     if (state != InternalState::SLEEPING) {
-      return BUSY;
+      return returnvalue::OK;
     }
     replyWasReceived = this->replyWasReceived;
   }
@@ -728,7 +733,7 @@ ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buf
     *size = replyLen;
   }
   replyLen = 0;
-  return replyResult;
+  return returnvalue::OK;
 }
 
 ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
@@ -782,8 +787,10 @@ ReturnValue_t StrComHandler::handleSerialReception() {
                << std::endl;
     return FAILED;
   } else if (bytesRead > 0) {
-    // sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
-    // arrayprinter::print(recBuf.data(), bytesRead);
+    if (PACKET_WIRETAPPING) {
+      sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
+      arrayprinter::print(recBuf.data(), bytesRead);
+    }
     datalinkLayer.feedData(recBuf.data(), bytesRead);
   }
   return OK;
@@ -797,6 +804,10 @@ ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
     handleSerialReception();
     result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
     if (result == returnvalue::OK) {
+      if (PACKET_WIRETAPPING) {
+        sif::debug << "Received STR reply frame" << std::endl;
+        arrayprinter::print(replyPtr, replyLen);
+      }
       return returnvalue::OK;
     } else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
       triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);

linux/acs/SusPolling.cpp

@@ -170,18 +170,12 @@ ReturnValue_t SusPolling::handleSusPolling() {
       }
       MutexGuard mg(ipcLock);
       susDevs[idx].ownReply.tempRaw = ((rawReply[0] & 0x0f) << 8) | rawReply[1];
-      // Reply is all ones. Sensor is probably off or faulty when
-      // it should not be.
-      if (susDevs[idx].ownReply.tempRaw == 0x0fff) {
-        susDevs[idx].replyResult = returnvalue::FAILED;
-      } else {
-        susDevs[idx].replyResult = returnvalue::OK;
-        for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
-          susDevs[idx].ownReply.channelsRaw[chIdx] =
-              (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
-        }
-        susDevs[idx].ownReply.dataWasSet = true;
+      susDevs[idx].replyResult = returnvalue::OK;
+      for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
+        susDevs[idx].ownReply.channelsRaw[chIdx] =
+            (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
       }
+      susDevs[idx].ownReply.dataWasSet = true;
     }
   }
   return OK;

linux/boardtest/UartTestClass.h

@@ -11,7 +11,7 @@
 
 #include <array>
 
-//#include "lwgps/lwgps.h"
+// #include "lwgps/lwgps.h"
 #include "test/TestTask.h"
 
 class ScexUartReader;

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 313 translations.
  * @details
- * Generated on: 2023-05-17 17:15:34
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateEvents.h"
 
@@ -100,10 +100,16 @@ const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
 const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
+const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
+const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
+const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
+const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
+const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
+const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@@ -127,6 +133,8 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
+const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
+const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -139,6 +147,7 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
+const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@@ -166,6 +175,7 @@ const char *PDEC_TRYING_RESET_NO_INIT_STRING = "PDEC_TRYING_RESET_NO_INIT";
 const char *PDEC_RESET_FAILED_STRING = "PDEC_RESET_FAILED";
 const char *OPEN_IRQ_FILE_FAILED_STRING = "OPEN_IRQ_FILE_FAILED";
 const char *PDEC_INIT_FAILED_STRING = "PDEC_INIT_FAILED";
+const char *PDEC_CONFIG_CORRUPTED_STRING = "PDEC_CONFIG_CORRUPTED";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -260,6 +270,7 @@ const char *TX_OFF_STRING = "TX_OFF";
 const char *MISSING_PACKET_STRING = "MISSING_PACKET";
 const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
 const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *FS_UNUSABLE_STRING = "FS_UNUSABLE";
 const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
 const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
 const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
@@ -277,6 +288,8 @@ 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 *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_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";
@@ -285,6 +298,9 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
+const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
+const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
+const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@@ -300,6 +316,8 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
+const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
+const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -493,6 +511,8 @@ const char *translateEvents(Event event) {
       return MEKF_INVALID_MODE_VIOLATION_STRING;
     case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
+    case (11208):
+      return TLE_TOO_OLD_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -501,6 +521,16 @@ const char *translateEvents(Event event) {
       return SWITCHING_Q7S_DENIED_STRING;
     case (11303):
       return FDIR_REACTION_IGNORED_STRING;
+    case (11304):
+      return DATASET_READ_FAILED_STRING;
+    case (11305):
+      return VOLTAGE_OUT_OF_BOUNDS_STRING;
+    case (11306):
+      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
+    case (11307):
+      return POWER_LEVEL_LOW_STRING;
+    case (11308):
+      return POWER_LEVEL_CRITICAL_STRING;
     case (11400):
       return GPIO_PULL_HIGH_FAILED_STRING;
     case (11401):
@@ -547,6 +577,10 @@ const char *translateEvents(Event event) {
       return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
     case (11606):
       return MPSOC_SHUTDOWN_FAILED_STRING;
+    case (11607):
+      return SUPV_NOT_ON_STRING;
+    case (11608):
+      return SUPV_REPLY_TIMEOUT_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -571,6 +605,8 @@ const char *translateEvents(Event event) {
       return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
     case (11902):
       return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
+    case (11903):
+      return COM_ERROR_REPLY_RECEIVED_STRING;
     case (12001):
       return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (12002):
@@ -625,6 +661,8 @@ const char *translateEvents(Event event) {
       return OPEN_IRQ_FILE_FAILED_STRING;
     case (12414):
       return PDEC_INIT_FAILED_STRING;
+    case (12415):
+      return PDEC_CONFIG_CORRUPTED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -813,6 +851,8 @@ const char *translateEvents(Event event) {
       return EXPERIMENT_TIMEDOUT_STRING;
     case (13802):
       return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13803):
+      return FS_UNUSABLE_STRING;
     case (13901):
       return SET_CONFIGFILEVALUE_FAILED_STRING;
     case (13902):
@@ -847,6 +887,10 @@ const char *translateEvents(Event event) {
       return I2C_REBOOT_STRING;
     case (14012):
       return PDEC_REBOOT_STRING;
+    case (14013):
+      return FIRMWARE_INFO_STRING;
+    case (14014):
+      return ACTIVE_SD_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -863,6 +907,12 @@ const char *translateEvents(Event event) {
       return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
     case (14108):
       return MGT_OVERHEATING_STRING;
+    case (14109):
+      return TCS_SWITCHING_HEATER_ON_STRING;
+    case (14110):
+      return TCS_SWITCHING_HEATER_OFF_STRING;
+    case (14111):
+      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):
@@ -893,6 +943,10 @@ const char *translateEvents(Event event) {
       return DUMP_HK_CANCELLED_STRING;
     case (14314):
       return DUMP_CFDP_CANCELLED_STRING;
+    case (14500):
+      return TEMPERATURE_ALL_ONES_START_STRING;
+    case (14501):
+      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,14 +1,15 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 175 translations.
- * Generated on: 2023-05-17 17:15:34
+ * Contains 177 translations.
+ * Generated on: 2023-10-10 13:50:27
  */
 #include "translateObjects.h"
 
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
@@ -169,6 +170,7 @@ const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
+const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@@ -190,6 +192,8 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000004:
+      return POWER_CONTROLLER_STRING;
     case 0x43000006:
       return GLOBAL_JSON_CFG_STRING;
     case 0x43400001:
@@ -510,6 +514,8 @@ const char *translateObject(object_id_t object) {
       return TCS_SUBSYSTEM_STRING;
     case 0x73010004:
       return COM_SUBSYSTEM_STRING;
+    case 0x73010005:
+      return EPS_SUBSYSTEM_STRING;
     case 0x73020001:
       return MISC_TM_STORE_STRING;
     case 0x73020002:

linux/ipcore/AxiPtmeConfig.cpp

@@ -16,9 +16,9 @@ AxiPtmeConfig::AxiPtmeConfig(object_id_t objectId, std::string axiUio, int mapNu
 AxiPtmeConfig::~AxiPtmeConfig() {}
 
 ReturnValue_t AxiPtmeConfig::initialize() {
-  ReturnValue_t result = returnvalue::OK;
   UioMapper uioMapper(axiUio, mapNum);
-  result = uioMapper.getMappedAdress(&baseAddress, UioMapper::Permissions::READ_WRITE);
+  ReturnValue_t result =
+      uioMapper.getMappedAdress(&baseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -26,8 +26,7 @@ ReturnValue_t AxiPtmeConfig::initialize() {
 }
 
 ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
-  ReturnValue_t result = returnvalue::OK;
-  result = mutex->lockMutex(timeoutType, mutexTimeout);
+  ReturnValue_t result = mutex->lockMutex(timeoutType, mutexTimeout);
   if (result != returnvalue::OK) {
     sif::warning << "AxiPtmeConfig::writeCaduRateReg: Failed to lock mutex" << std::endl;
     return returnvalue::FAILED;
@@ -41,6 +40,11 @@ ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
   return returnvalue::OK;
 }
 
+uint8_t AxiPtmeConfig::readCaduRateReg() {
+  MutexGuard mg(mutex);
+  return static_cast<uint8_t>(*(baseAddress + CADU_BITRATE_REG));
+}
+
 void AxiPtmeConfig::enableTxclockManipulator() {
   writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR);
 }

linux/ipcore/AxiPtmeConfig.h

@@ -38,6 +38,7 @@ class AxiPtmeConfig : public SystemObject {
    *        frequency of the clock connected to the bit clock input of PTME.
    */
   ReturnValue_t writeCaduRateReg(uint8_t rateVal);
+  uint8_t readCaduRateReg();
 
   /**
    * @brief Next to functions control the tx clock manipulator component

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,27 @@ 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 {
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
     abortPacketTransfer();
     return returnvalue::FAILED;
   }
+  for (size_t idx = 0; idx < size; idx++) {
+    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+      abortPacketTransfer();
+      return returnvalue::FAILED;
+    }
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
+  }
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+    abortPacketTransfer();
+    return returnvalue::FAILED;
+  }
+  completePacketTransfer();
   return returnvalue::OK;
 }
 
@@ -98,63 +58,49 @@ 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;
+  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(); }
 
+inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
+  uint32_t reg;
+  uint32_t idx = 0;
+  while (idx < maxCycles) {
+    reg = *vcBaseReg;
+    // Busy bit.
+    if (not((reg >> 5) & 0b1)) {
+      return true;
+    }
+    idx++;
+  }
+  return false;
+}
+
 ReturnValue_t PapbVcInterface::sendTestFrame() {
   /** Size of one complete transfer frame data field amounts to 1105 bytes */
   uint8_t testPacket[1105];

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;
@@ -81,11 +80,9 @@ class PapbVcInterface : public VirtualChannelIF {
 
   static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
+  static constexpr uint32_t MAX_BUSY_POLLS = 1000;
 
   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 +117,15 @@ 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;
+
+  inline bool pollReadyForOctet(uint32_t maxCycles) 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)

linux/ipcore/PdecConfig.cpp

@@ -22,11 +22,11 @@ ReturnValue_t PdecConfig::write() {
   if (result != returnvalue::OK) {
     return result;
   }
-  result = writeFrameHeaderFirstOctet();
+  result = writeFrameHeaderFirstWord();
   if (result != returnvalue::OK) {
     return result;
   }
-  result = writeFrameHeaderSecondOctet();
+  result = writeFrameHeaderSecondWord();
   if (result != returnvalue::OK) {
     return result;
   }
@@ -77,7 +77,7 @@ ReturnValue_t PdecConfig::setPositiveWindow(uint8_t pw) {
     return result;
   }
   // Rewrite second config word which contains the positive window parameter
-  writeFrameHeaderSecondOctet();
+  writeFrameHeaderSecondWord();
   return returnvalue::OK;
 }
 
@@ -92,7 +92,7 @@ ReturnValue_t PdecConfig::setNegativeWindow(uint8_t nw) {
     return result;
   }
   // Rewrite second config word which contains the negative window parameter
-  writeFrameHeaderSecondOctet();
+  writeFrameHeaderSecondWord();
   return returnvalue::OK;
 }
 
@@ -114,43 +114,23 @@ ReturnValue_t PdecConfig::getNegativeWindow(uint8_t& negativeWindow) {
   return returnvalue::OK;
 }
 
-ReturnValue_t PdecConfig::writeFrameHeaderFirstOctet() {
+ReturnValue_t PdecConfig::writeFrameHeaderFirstWord() {
   uint32_t word = 0;
-  word |= (VERSION_ID << 30);
-
-  // Setting the bypass flag and the control command flag should not have any
-  // implication on the operation of the PDEC IP Core
-  word |= (BYPASS_FLAG << 29);
-  word |= (CONTROL_COMMAND_FLAG << 28);
-
-  word |= (RESERVED_FIELD_A << 26);
-  word |= (SPACECRAFT_ID << 16);
-  word |= (VIRTUAL_CHANNEL << 10);
-  word |= (DUMMY_BITS << 8);
-  uint8_t positiveWindow = 0;
-  ReturnValue_t result =
-      localParameterHandler.getValue(pdecconfigdefs::paramkeys::POSITIVE_WINDOW, positiveWindow);
+  ReturnValue_t result = createFirstWord(&word);
   if (result != returnvalue::OK) {
     return result;
   }
-  word |= static_cast<uint32_t>(positiveWindow);
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET) = word;
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET + OFFSET_FIRST_CONFIG_WORD) = word;
   return returnvalue::OK;
 }
 
-ReturnValue_t PdecConfig::writeFrameHeaderSecondOctet() {
-  uint8_t negativeWindow = 0;
-  ReturnValue_t result =
-      localParameterHandler.getValue(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW, negativeWindow);
+ReturnValue_t PdecConfig::writeFrameHeaderSecondWord() {
+  uint32_t word = 0;
+  ReturnValue_t result = createSecondWord(&word);
   if (result != returnvalue::OK) {
     return result;
   }
-  uint32_t word = 0;
-  word = 0;
-  word |= (static_cast<uint32_t>(negativeWindow) << 24);
-  word |= (HIGH_AU_MAP_ID << 16);
-  word |= (ENABLE_DERANDOMIZER << 8);
-  *(memoryBaseAddress + FRAME_HEADER_OFFSET + 1) = word;
+  *(memoryBaseAddress + FRAME_HEADER_OFFSET + OFFSET_SECOND_CONFIG_WORD) = word;
   return returnvalue::OK;
 }
 
@@ -189,3 +169,49 @@ uint8_t PdecConfig::getOddParity(uint8_t number) {
   parityBit = ~(countBits & 0x1) & 0x1;
   return parityBit;
 }
+
+ReturnValue_t PdecConfig::createFirstWord(uint32_t* word) {
+  *word = 0;
+  *word |= (VERSION_ID << 30);
+
+  // Setting the bypass flag and the control command flag should not have any
+  // implication on the operation of the PDEC IP Core
+  *word |= (BYPASS_FLAG << 29);
+  *word |= (CONTROL_COMMAND_FLAG << 28);
+
+  *word |= (RESERVED_FIELD_A << 26);
+  *word |= (SPACECRAFT_ID << 16);
+  *word |= (VIRTUAL_CHANNEL << 10);
+  *word |= (DUMMY_BITS << 8);
+  uint8_t positiveWindow = 0;
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::POSITIVE_WINDOW, positiveWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *word |= static_cast<uint32_t>(positiveWindow);
+  return returnvalue::OK;
+}
+
+ReturnValue_t PdecConfig::createSecondWord(uint32_t* word) {
+  uint8_t negativeWindow = 0;
+  ReturnValue_t result =
+      localParameterHandler.getValue(pdecconfigdefs::paramkeys::NEGATIVE_WINDOW, negativeWindow);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  *word = 0;
+  *word = 0;
+  *word |= (static_cast<uint32_t>(negativeWindow) << 24);
+  *word |= (HIGH_AU_MAP_ID << 16);
+  *word |= (ENABLE_DERANDOMIZER << 8);
+  return returnvalue::OK;
+}
+
+uint32_t PdecConfig::readbackFirstWord() {
+  return *(memoryBaseAddress + FRAME_HEADER_OFFSET + OFFSET_FIRST_CONFIG_WORD);
+}
+
+uint32_t PdecConfig::readbackSecondWord() {
+  return *(memoryBaseAddress + FRAME_HEADER_OFFSET + OFFSET_SECOND_CONFIG_WORD);
+}

linux/ipcore/PdecConfig.h

@@ -48,6 +48,39 @@ class PdecConfig {
   ReturnValue_t getPositiveWindow(uint8_t& positiveWindow);
   ReturnValue_t getNegativeWindow(uint8_t& negativeWindow);
 
+  /**
+   * @brief	Creates the first word of the PDEC configuration
+   *
+   * @param word	The created word will be written to this pointer
+   *
+   * @return OK if successful, otherwise error return value
+   *
+   */
+  ReturnValue_t createFirstWord(uint32_t* word);
+
+  /**
+   * @brief	Creates the second word of the PDEC configuration
+   *
+   * @param word	The created word will be written to this pointer
+   *
+   * @return OK if successful, otherwise error return value
+   */
+  ReturnValue_t createSecondWord(uint32_t* word);
+
+  /**
+   * @brief	Reads first config word from the config memory
+   *
+   * @return The config word
+   */
+  uint32_t readbackFirstWord();
+
+  /**
+   * @brief	Reads the second config word from the config memory
+   *
+   * @return The config word
+   */
+  uint32_t readbackSecondWord();
+
  private:
   // TC transfer frame configuration parameters
   static const uint8_t VERSION_ID = 0;
@@ -66,6 +99,8 @@ class PdecConfig {
 
   // 0x200 / 4 = 0x80
   static const uint32_t FRAME_HEADER_OFFSET = 0x80;
+  static const uint32_t OFFSET_FIRST_CONFIG_WORD = 0;
+  static const uint32_t OFFSET_SECOND_CONFIG_WORD = 1;
 
   static const uint32_t MAP_ADDR_LUT_OFFSET = 0xA0;
   static const uint32_t MAP_CLK_FREQ_OFFSET = 0x90;
@@ -102,8 +137,8 @@ class PdecConfig {
    */
   ReturnValue_t createPersistentConfig();
 
-  ReturnValue_t writeFrameHeaderFirstOctet();
-  ReturnValue_t writeFrameHeaderSecondOctet();
+  ReturnValue_t writeFrameHeaderFirstWord();
+  ReturnValue_t writeFrameHeaderSecondWord();
   void writeMapConfig();
 
   /**

linux/ipcore/PdecHandler.cpp

@@ -53,23 +53,30 @@ ReturnValue_t PdecHandler::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
-  ReturnValue_t result = returnvalue::OK;
-
   UioMapper regMapper(uioNames.registers);
-  result = regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
+  ReturnValue_t result =
+      regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-  UioMapper configMemMapper(uioNames.configMemory);
-  result = configMemMapper.getMappedAdress(&memoryBaseAddress, UioMapper::Permissions::READ_WRITE);
-  if (result != returnvalue::OK) {
+
+  int fd = 0;
+  if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
+    sif::error << "PdecHandler::initialize: Opening /dev/mem failed" << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  };
+  memoryBaseAddress = static_cast<uint32_t*>(
+      mmap(0, PDEC_CFG_MEM_SIZE, static_cast<int>(UioMapper::Permissions::READ_WRITE), MAP_SHARED,
+           fd, PDEC_CFG_MEM_PHY_ADDR));
+  if (memoryBaseAddress == nullptr) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
-  } else {
-    pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
   }
-  UioMapper ramMapper(uioNames.ramMemory);
-  result = ramMapper.getMappedAdress(&ramBaseAddress, UioMapper::Permissions::READ_WRITE);
-  if (result != returnvalue::OK) {
+  pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
+
+  ramBaseAddress = static_cast<uint32_t*>(mmap(0, PDEC_RAM_SIZE,
+                                               static_cast<int>(UioMapper::Permissions::READ_WRITE),
+                                               MAP_SHARED, fd, PDEC_RAM_PHY_ADDR));
+  if (ramBaseAddress == nullptr) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
@@ -478,6 +485,7 @@ bool PdecHandler::checkFrameAna(uint32_t pdecFar) {
     }
     case (FrameAna_t::FRAME_DIRTY): {
       triggerEvent(INVALID_TC_FRAME, FRAME_DIRTY_RETVAL);
+      checkConfig();
       sif::warning << "PdecHandler::checkFrameAna: Frame dirty" << std::endl;
       break;
     }
@@ -577,6 +585,30 @@ void PdecHandler::handleIReason(uint32_t pdecFar, ReturnValue_t parameter1) {
   }
 }
 
+void PdecHandler::checkConfig() {
+  uint32_t firstWord = 0;
+  ReturnValue_t result = pdecConfig.createFirstWord(&firstWord);
+  if (result != returnvalue::OK) {
+    // This should normally never happen during runtime. So here is just
+    // output a warning
+    sif::warning << "PdecHandler::checkConfig: Failed to create first word" << std::endl;
+    return;
+  }
+  uint32_t secondWord = 0;
+  result = pdecConfig.createSecondWord(&secondWord);
+  if (result != returnvalue::OK) {
+    // This should normally never happen during runtime. So here is just
+    // output a warning
+    sif::warning << "PdecHandler::checkConfig: Failed to create second word" << std::endl;
+    return;
+  }
+  uint32_t readbackFirstWord = pdecConfig.readbackFirstWord();
+  uint32_t readbackSecondWord = pdecConfig.readbackSecondWord();
+  if (firstWord != readbackFirstWord or secondWord != readbackSecondWord) {
+    triggerEvent(PDEC_CONFIG_CORRUPTED, readbackFirstWord, readbackSecondWord);
+  }
+}
+
 void PdecHandler::handleNewTc() {
   ReturnValue_t result = returnvalue::OK;
 

linux/ipcore/PdecHandler.h

@@ -51,6 +51,10 @@ class PdecHandler : public SystemObject,
                     public ReceivesParameterMessagesIF {
  public:
   static constexpr dur_millis_t IRQ_TIMEOUT_MS = 500;
+  static constexpr uint32_t PDEC_CFG_MEM_SIZE = 0x1000;
+  static constexpr uint32_t PDEC_CFG_MEM_PHY_ADDR = 0x24000000;
+  static constexpr uint32_t PDEC_RAM_SIZE = 0x10000;
+  static constexpr uint32_t PDEC_RAM_PHY_ADDR = 0x26000000;
 
   enum class Modes { POLLED, IRQ };
 
@@ -282,6 +286,11 @@ class PdecHandler : public SystemObject,
    */
   void handleIReason(uint32_t pdecFar, ReturnValue_t parameter1);
 
+  /**
+   * @brief	Checks if PDEC configuration is still correct
+   */
+  void checkConfig();
+
   /**
    * @brief   Handles the reception of new TCs. Reads the pointer to the storage location of the
    *          new TC segment, extracts the PUS packet and forwards the data to the object

linux/ipcore/PtmeConfig.cpp

@@ -26,6 +26,11 @@ ReturnValue_t PtmeConfig::setRate(uint32_t bitRate) {
   return axiPtmeConfig->writeCaduRateReg(static_cast<uint8_t>(rateVal));
 }
 
+uint32_t PtmeConfig::getRate() {
+  uint8_t rateReg = axiPtmeConfig->readCaduRateReg();
+  return (BIT_CLK_FREQ / (rateReg + 1));
+}
+
 void PtmeConfig::invertTxClock(bool invert) {
   if (invert) {
     axiPtmeConfig->enableTxclockInversion();

linux/ipcore/PtmeConfig.h

@@ -32,6 +32,7 @@ class PtmeConfig : public SystemObject {
    *          of the CADU clock due to the convolutional code added by the s-Band transceiver.
    */
   ReturnValue_t setRate(uint32_t bitRate);
+  uint32_t getRate();
 
   /**
    * @brief Will change the time the tx data signal is updated with respect to the tx clock

linux/ipcore/pdec.h

@@ -71,6 +71,10 @@ static constexpr Event OPEN_IRQ_FILE_FAILED = event::makeEvent(SUBSYSTEM_ID, 13,
 //! [EXPORT] : [COMMENT] PDEC initialization failed. This might also be due to the persistent
 //! confiuration never becoming available, for example due to SD card issues.
 static constexpr Event PDEC_INIT_FAILED = event::makeEvent(SUBSYSTEM_ID, 14, severity::HIGH);
+//! [EXPORT] : [COMMENT] The PDEC configuration area has been corrupted
+//! P1: The first configuration word
+//! P2: The second configuration word
+static constexpr Event PDEC_CONFIG_CORRUPTED = event::makeEvent(SUBSYSTEM_ID, 15, severity::HIGH);
 
 // Action IDs
 static constexpr ActionId_t PRINT_CLCW = 0;

linux/payload/PlocMpsocHandler.cpp

@@ -188,72 +188,27 @@ void PlocMpsocHandler::doStartUp() {
     startupState = StartupState::HW_INIT;
   }
   if (startupState == StartupState::HW_INIT) {
-#ifdef XIPHOS_Q7S
-#if not OBSW_MPSOC_JTAG_BOOT == 1
-    switch (powerState) {
-      case PowerState::OFF:
-        commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
-        powerState = PowerState::BOOTING;
-        return;
-      case PowerState::ON:
-        uartIsolatorSwitch.pullHigh();
-        startupState = StartupState::WAIT_CYCLES;
-        break;
-      default:
-        return;
-    }
-#else
-    uartIsolatorSwitch.pullHigh();
-    startupState = StartupState::WAIT_CYCLES;
-#endif /* not MSPOC_JTAG_BOOT == 1 */
-#else
-    startupState = StartupState::WAIT_CYCLES;
-    powerState = PowerState::ON;
-#endif /* XIPHOS_Q7S */
-  }
-  // Need to wait, MPSoC still not booted properly, requesting HK without these wait cycles does
-  // not work, no replies..
-  if (startupState == StartupState::WAIT_CYCLES) {
-    waitCycles++;
-    if (waitCycles >= 8) {
+    if (handleHwStartup()) {
       startupState = StartupState::DONE;
-      waitCycles = 0;
     }
   }
   if (startupState == StartupState::DONE) {
     setMode(_MODE_TO_ON);
     hkReport.setReportingEnabled(true);
+    powerState = PowerState::IDLE;
     startupState = StartupState::IDLE;
   }
 }
 
 void PlocMpsocHandler::doShutDown() {
-#ifdef XIPHOS_Q7S
-#if not OBSW_MPSOC_JTAG_BOOT == 1
-  if (powerState == PowerState::ON) {
-    uartIsolatorSwitch.pullLow();
-    commandActionHelper.commandAction(supervisorHandler, supv::SHUTDOWN_MPSOC);
-    powerState = PowerState::SHUTDOWN;
-    return;
-  } else if (powerState == PowerState::SHUTDOWN) {
-    // Wait till power state is OFF.
-    return;
+  if (handleHwShutdown()) {
+    hkReport.setReportingEnabled(false);
+    setMode(_MODE_POWER_DOWN);
+    commandIsPending = false;
+    sequenceCount = 0;
+    powerState = PowerState::IDLE;
+    startupState = StartupState::IDLE;
   }
-#else
-  uartIsolatorSwitch.pullLow();
-  powerState = PowerState::OFF;
-#endif
-#endif
-
-  if (specialComHelper != nullptr) {
-    specialComHelper->stopProcess();
-  }
-  hkReport.setReportingEnabled(false);
-  setMode(_MODE_POWER_DOWN);
-  commandIsPending = false;
-  sequenceCount = 0;
-  specialComHelperExecuting = false;
-  startupState = StartupState::IDLE;
 }
 
 ReturnValue_t PlocMpsocHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
@@ -1247,15 +1202,11 @@ void PlocMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
   switch (actionId) {
     case supv::START_MPSOC: {
       sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to start MPSoC" << std::endl;
-      // This usually happens when the supervisor handler is in off mode
-      powerState = PowerState::OFF;
-      setMode(MODE_OFF);
       break;
     }
     case supv::SHUTDOWN_MPSOC: {
       triggerEvent(MPSOC_SHUTDOWN_FAILED);
       sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to shutdown MPSoC" << std::endl;
-      powerState = PowerState::OFF;
       break;
     }
     default:
@@ -1263,6 +1214,7 @@ void PlocMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
                  << std::endl;
       break;
   }
+  powerState = PowerState::SUPV_FAILED;
 }
 
 void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
@@ -1270,18 +1222,24 @@ void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, ui
 }
 
 void PlocMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) {
-  if (actionId != supv::EXE_REPORT) {
-    sif::debug << "PlocMPSoCHandler::completionSuccessfulReceived: Did not expect this action "
-               << "ID" << std::endl;
+  if (actionId == supv::ACK_REPORT) {
+    sif::warning
+        << "PlocMpsocHandler::completionSuccessfulReceived: Only received ACK report. Consider "
+           "increasing the MPSoC boot timer."
+        << std::endl;
+  } else if (actionId != supv::EXE_REPORT) {
+    sif::warning << "PlocMpsocHandler::completionSuccessfulReceived: Did not expect the action "
+                 << "ID " << actionId << std::endl;
     return;
   }
   switch (powerState) {
-    case PowerState::BOOTING: {
-      powerState = PowerState::ON;
+    case PowerState::PENDING_STARTUP: {
+      mpsocBootTransitionCd.resetTimer();
+      powerState = PowerState::DONE;
       break;
     }
-    case PowerState::SHUTDOWN: {
-      powerState = PowerState::OFF;
+    case PowerState::PENDING_SHUTDOWN: {
+      powerState = PowerState::DONE;
       break;
     }
     default: {
@@ -1409,36 +1367,117 @@ void PlocMpsocHandler::disableExeReportReply() {
   info->command->second.expectedReplies = 0;
 }
 
+void PlocMpsocHandler::stopSpecialComHelper() {
+  if (specialComHelper != nullptr) {
+    specialComHelper->stopProcess();
+  }
+  specialComHelperExecuting = false;
+}
+
+bool PlocMpsocHandler::handleHwStartup() {
+#if OBSW_MPSOC_JTAG_BOOT == 1
+  uartIsolatorSwitch.pullHigh();
+  startupState = StartupState::WAIT_CYCLES;
+  return true;
+#endif
+  if (powerState == PowerState::IDLE) {
+    if (supv::SUPV_ON) {
+      commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
+      supvTransitionCd.resetTimer();
+      powerState = PowerState::PENDING_STARTUP;
+    } else {
+      triggerEvent(SUPV_NOT_ON, 1);
+      // Set back to OFF for now, failing the transition.
+      setMode(MODE_OFF);
+    }
+  }
+  if (powerState == PowerState::SUPV_FAILED) {
+    setMode(MODE_OFF);
+    powerState = PowerState::IDLE;
+    return false;
+  }
+  if (powerState == PowerState::PENDING_STARTUP) {
+    if (supvTransitionCd.hasTimedOut()) {
+      // Process with transition nonetheless..
+      triggerEvent(SUPV_REPLY_TIMEOUT);
+      powerState = PowerState::DONE;
+    } else {
+      return false;
+    }
+  }
+  if (powerState == PowerState::DONE) {
+    if (mpsocBootTransitionCd.hasTimedOut()) {
+      // Wait a bit for the MPSoC to fully boot.
+      uartIsolatorSwitch.pullHigh();
+      powerState = PowerState::IDLE;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool PlocMpsocHandler::handleHwShutdown() {
+  stopSpecialComHelper();
+  uartIsolatorSwitch.pullLow();
+#if OBSW_MPSOC_JTAG_BOOT == 1
+  powerState = PowerState::DONE;
+  return true;
+#endif
+
+  if (powerState == PowerState::IDLE) {
+    if (supv::SUPV_ON) {
+      commandActionHelper.commandAction(supervisorHandler, supv::SHUTDOWN_MPSOC);
+      supvTransitionCd.resetTimer();
+      powerState = PowerState::PENDING_SHUTDOWN;
+    } else {
+      triggerEvent(SUPV_NOT_ON, 0);
+      powerState = PowerState::DONE;
+    }
+  }
+  if (powerState == PowerState::PENDING_SHUTDOWN) {
+    if (supvTransitionCd.hasTimedOut()) {
+      powerState = PowerState::DONE;
+      // Process with transition nonetheless..
+      triggerEvent(SUPV_REPLY_TIMEOUT);
+      return true;
+    } else {
+      // Wait till power state is OFF.
+      return false;
+    }
+  }
+  return true;
+}
+
 void PlocMpsocHandler::handleActionCommandFailure(ActionId_t actionId) {
   switch (actionId) {
     case supv::ACK_REPORT:
     case supv::EXE_REPORT:
       break;
     default:
-      sif::debug << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect this action ID "
-                 << std::endl;
+      sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect the action ID "
+                   << actionId << std::endl;
       return;
   }
   switch (powerState) {
-    case PowerState::BOOTING: {
+    case PowerState::PENDING_STARTUP: {
       sif::info << "PlocMPSoCHandler::handleActionCommandFailure: MPSoC boot command failed"
                 << std::endl;
       // This is commonly the case when the MPSoC is already operational. Thus the power state is
       // set to on here
-      powerState = PowerState::ON;
       break;
     }
-    case PowerState::SHUTDOWN: {
+    case PowerState::PENDING_SHUTDOWN: {
       // FDIR will intercept event and switch PLOC power off
       triggerEvent(MPSOC_SHUTDOWN_FAILED);
       sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Failed to shutdown MPSoC"
                    << std::endl;
-      powerState = PowerState::OFF;
       break;
     }
     default:
       break;
   }
+  powerState = PowerState::SUPV_FAILED;
   return;
 }
 
@@ -1466,3 +1505,16 @@ void PlocMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
   }
   disableAllReplies();
 }
+
+ReturnValue_t PlocMpsocHandler::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                                 uint32_t* msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}

linux/payload/PlocMpsocHandler.h

@@ -5,6 +5,7 @@
 #include <linux/payload/mpsocRetvals.h>
 #include <linux/payload/plocMpsocHelpers.h>
 #include <linux/payload/plocSupvDefs.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
 #include <string>
 
@@ -103,11 +104,17 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
   //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and
   //! thus also to shutdown the supervisor.
   static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH);
+  //! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for
+  //! ON transition.
+  static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW);
+  static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW);
 
   static const uint16_t APID_MASK = 0x7FF;
   static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
 
   mpsoc::HkReport hkReport;
+  Countdown mpsocBootTransitionCd = Countdown(6500);
+  Countdown supvTransitionCd = Countdown(3000);
 
   MessageQueueIF* eventQueue = nullptr;
   MessageQueueIF* commandActionHelperQueue = nullptr;
@@ -186,12 +193,11 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   size_t foundPacketLen = 0;
   TelemetryBuffer tmBuffer;
-  uint32_t waitCycles = 0;
 
-  enum class StartupState { IDLE, HW_INIT, WAIT_CYCLES, DONE } startupState = StartupState::IDLE;
-  enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };
+  enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
+  enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
 
-  PowerState powerState = PowerState::OFF;
+  PowerState powerState = PowerState::IDLE;
 
   /**
    * @brief   Handles events received from the PLOC MPSoC helper
@@ -299,8 +305,15 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
   ReturnValue_t prepareTcModeReplay();
 
   void cmdDoneHandler(bool success, ReturnValue_t result);
+  bool handleHwStartup();
+  bool handleHwShutdown();
+  void stopSpecialComHelper();
 
   void handleActionCommandFailure(ActionId_t actionId);
+
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t* msToReachTheMode) override;
 };
 
 #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */

linux/payload/PlocSupervisorHandler.cpp

@@ -19,6 +19,8 @@
 using namespace supv;
 using namespace returnvalue;
 
+std::atomic_bool supv::SUPV_ON = false;
+
 PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, CookieIF* comCookie,
                                              Gpio uartIsolatorSwitch, power::Switch_t powerSwitch,
                                              PlocSupvUartManager& supvHelper)
@@ -155,21 +157,30 @@ void PlocSupervisorHandler::doStartUp() {
     startupState = StartupState::ON;
   }
   if (startupState == StartupState::ON) {
+    hkset.setReportingEnabled(true);
+    supv::SUPV_ON = true;
     setMode(_MODE_TO_ON);
   }
 }
 
 void PlocSupervisorHandler::doShutDown() {
   setMode(_MODE_POWER_DOWN);
+  hkset.setReportingEnabled(false);
+  hkset.setValidity(false, true);
   shutdownCmdSent = false;
   packetInBuffer = false;
   nextReplyId = supv::NONE;
   uartManager.stop();
   uartIsolatorSwitch.pullLow();
+  supv::SUPV_ON = false;
   startupState = StartupState::OFF;
 }
 
 ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+  if (not commandIsExecuting(GET_HK_REPORT)) {
+    *id = GET_HK_REPORT;
+    return buildCommandFromCommand(*id, nullptr, 0);
+  }
   return NOTHING_TO_SEND;
 }
 
@@ -195,11 +206,13 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
       break;
     }
     case START_MPSOC: {
+      sif::info << "PLOC SUPV: Starting MPSoC" << std::endl;
       prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::START_MPSOC));
       result = returnvalue::OK;
       break;
     }
     case SHUTDOWN_MPSOC: {
+      sif::info << "PLOC SUPV: Shutting down MPSoC" << std::endl;
       prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC));
       result = returnvalue::OK;
       break;
@@ -430,7 +443,7 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
   insertInReplyMap(MEMORY_CHECK, 5, nullptr, 0, false);
 
   // TM replies
-  insertInReplyMap(HK_REPORT, 3, &hkset, SIZE_HK_REPORT);
+  insertInReplyMap(HK_REPORT, 3, &hkset);
   insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_REPORT);
   insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT);
   insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT);
@@ -790,6 +803,8 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
   localDataPoolMap.emplace(supv::ADC_ENG_14, new PoolEntry<uint16_t>({0}));
   localDataPoolMap.emplace(supv::ADC_ENG_15, new PoolEntry<uint16_t>({0}));
 
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(hkset.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
@@ -918,7 +933,7 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
 ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
-  result = verifyPacket(data, supv::SIZE_HK_REPORT);
+  result = verifyPacket(data, tmReader.getFullPacketLen());
 
   if (result == result::CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
@@ -1518,7 +1533,13 @@ void PlocSupervisorHandler::disableAllReplies() {
 
   /* Disable ack reply */
   iter = deviceReplyMap.find(ACK_REPORT);
+  if (iter == deviceReplyMap.end()) {
+    return;
+  }
   DeviceReplyInfo* info = &(iter->second);
+  if (info == nullptr) {
+    return;
+  }
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
 
@@ -1972,6 +1993,20 @@ uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t mod
   return 7000;
 }
 
+ReturnValue_t PlocSupervisorHandler::checkModeCommand(Mode_t commandedMode,
+                                                      Submode_t commandedSubmode,
+                                                      uint32_t* msToReachTheMode) {
+  if (commandedMode != MODE_OFF) {
+    PoolReadGuard pg(&enablePl);
+    if (pg.getReadResult() == returnvalue::OK) {
+      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+        return NON_OP_STATE_OF_CHARGE;
+      }
+    }
+  }
+  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+}
+
 // ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
 //   uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK;
 //  TODO: Fix
@@ -2096,9 +2131,9 @@ uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t mod
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
-//#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
+// #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
 //   loggingReport.printSet();
-//#endif
+// #endif
 //   nextReplyId = supv::EXE_REPORT;
 //   return result;
 // }

linux/payload/PlocSupervisorHandler.h

@@ -3,6 +3,7 @@
 
 #include <linux/payload/PlocSupvUartMan.h>
 #include <linux/payload/plocSupvDefs.h>
+#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
 #include "OBSWConfig.h"
 #include "devices/powerSwitcherList.h"
@@ -395,6 +396,10 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   void handleExecutionFailureReport(ExecutionReport& report);
 
   void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
+
+  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
+  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
+                                 uint32_t* msToReachTheMode) override;
 };
 
 #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */

linux/payload/PlocSupvUartMan.cpp

@@ -274,12 +274,12 @@ ReturnValue_t PlocSupvUartManager::initiateUpdateContinuation() {
 }
 
 // ReturnValue_t PlocSupvHelper::startEventBufferRequest(std::string path) {
-//#ifdef XIPHOS_Q7S
+// #ifdef XIPHOS_Q7S
 //   ReturnValue_t result = FilesystemHelper::checkPath(path);
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
-//#endif
+// #endif
 //   if (not std::filesystem::exists(path)) {
 //     return PATH_NOT_EXISTS;
 //   }
@@ -836,11 +836,11 @@ uint32_t PlocSupvUartManager::getFileSize(std::string filename) {
 ReturnValue_t PlocSupvUartManager::handleEventBufferReception(ploc::SpTmReader& reader) {
   ReturnValue_t result = returnvalue::OK;
   // TODO: Fix
-  //#ifdef XIPHOS_Q7S
+  // #ifdef XIPHOS_Q7S
   //  if (not sdcMan->getActiveSdCard()) {
   //    return HasFileSystemIF::FILESYSTEM_INACTIVE;
   //  }
-  //#endif
+  // #endif
   //  std::string filename = Filenaming::generateAbsoluteFilename(
   //      eventBufferReq.path, eventBufferReq.filename, timestamping);
   //  std::ofstream file(filename, std::ios_base::app | std::ios_base::out);

linux/payload/plocSupvDefs.h

@@ -10,12 +10,15 @@
 #include <fsfw/tmtcpacket/ccsds/SpacePacketReader.h>
 #include <mission/payload/plocSpBase.h>
 
+#include <atomic>
 #include <optional>
 
 #include "eive/resultClassIds.h"
 
 namespace supv {
 
+extern std::atomic_bool SUPV_ON;
+
 namespace result {
 static const uint8_t INTERFACE_ID = CLASS_ID::SUPV_RETURN_VALUES_IF;
 
@@ -139,7 +142,6 @@ enum ReplyId : DeviceCommandId_t {
 // Size of complete space packet (6 byte header + size of data + 2 byte CRC)
 static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
-static const uint16_t SIZE_HK_REPORT = 52;
 static const uint16_t SIZE_BOOT_STATUS_REPORT = 24;
 static const uint16_t SIZE_LATCHUP_STATUS_REPORT = 31;
 static const uint16_t SIZE_LOGGING_REPORT = 73;

misc/eclipse/.cproject

@@ -57,7 +57,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -119,7 +120,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -187,7 +189,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -255,7 +258,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -418,7 +422,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -580,7 +585,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -750,7 +756,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -917,7 +924,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s|cmake-build-release-q7s-em|cmake-build-release-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/temp|cmake-build-release-q7s/_deps/etl-src/support|cmake-build-release-q7s/_deps/etl-src/subprojects|cmake-build-release-q7s/_deps/etl-src/scripts|cmake-build-release-q7s/_deps/etl-src/images|cmake-build-release-q7s/_deps/etl-src/examples|cmake-build-release-q7s/_deps/etl-src/cmake|cmake-build-release-q7s/_deps/etl-src/arduino|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s|cmake-build-release-q7s-em|cmake-build-release-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/temp|cmake-build-release-q7s/_deps/etl-src/support|cmake-build-release-q7s/_deps/etl-src/subprojects|cmake-build-release-q7s/_deps/etl-src/scripts|cmake-build-release-q7s/_deps/etl-src/images|cmake-build-release-q7s/_deps/etl-src/examples|cmake-build-release-q7s/_deps/etl-src/cmake|cmake-build-release-q7s/_deps/etl-src/arduino|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -1084,7 +1092,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -1149,7 +1158,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -1172,7 +1182,7 @@
 				</extensions>
 			</storageModule>
 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactName="${ProjName}" buildProperties="" description="" errorParsers="org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.CWDLocator;org.eclipse.cdt.core.GCCErrorParser" id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561" name="eive-q7s-debug-em" optionalBuildProperties="org.eclipse.cdt.docker.launcher.containerbuild.property.enablement=null,org.eclipse.cdt.docker.launcher.containerbuild.property.selectedvolumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.volumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.image=null,org.eclipse.cdt.docker.launcher.containerbuild.property.connection=null" parent="org.eclipse.cdt.build.core.emptycfg">
+				<configuration artifactName="${ProjName}" buildProperties="" description="" errorParsers="org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.CWDLocator;org.eclipse.cdt.core.GCCErrorParser" id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561" name="eive-q7s-debug-em" optionalBuildProperties="org.eclipse.cdt.docker.launcher.containerbuild.property.enablement=null,org.eclipse.cdt.docker.launcher.containerbuild.property.dockerdpath=,org.eclipse.cdt.docker.launcher.containerbuild.property.volumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.connection=unix:///var/run/docker.sock,org.eclipse.cdt.docker.launcher.containerbuild.property.selectedvolumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.image=null" parent="org.eclipse.cdt.build.core.emptycfg">
 					<folderInfo id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561." name="/" resourcePath="">
 						<toolChain id="ilg.gnuarmeclipse.managedbuild.cross.toolchain.base.1640701365" name="Arm Cross GCC" superClass="ilg.gnuarmeclipse.managedbuild.cross.toolchain.base">
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.architecture.564607779" name="Architecture" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.architecture" value="ilg.gnuarmeclipse.managedbuild.cross.option.architecture.arm" valueType="enumerated"/>
@@ -1317,7 +1327,9 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug-q7s|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug-q7s|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="cmake-build-debug-q7s-em/_deps/etl-src/include"/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@@ -1386,7 +1398,8 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>

mission/acs/SusHandler.cpp

@@ -20,6 +20,9 @@ void SusHandler::doStartUp() {
   }
   if (internalState == InternalState::STARTUP) {
     if (commandExecuted) {
+      if (waitingForRecovery) {
+        waitingForRecovery = false;
+      }
       setMode(MODE_ON);
       internalState = InternalState::NONE;
       commandExecuted = false;
@@ -30,6 +33,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;
@@ -82,15 +86,36 @@ ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t len, DeviceC
 }
 ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
   const auto *reply = reinterpret_cast<const acs::SusReply *>(packet);
-  if (reply->dataWasSet) {
-    if (internalState == InternalState::STARTUP) {
-      commandExecuted = true;
-    }
-    PoolReadGuard pg(&dataset);
-    dataset.setValidity(true, true);
-    dataset.tempC = max1227::getTemperature(reply->tempRaw);
-    std::memcpy(dataset.channels.value, reply->channelsRaw, sizeof(reply->channelsRaw));
+  if (!reply->dataWasSet) {
+    return returnvalue::OK;
   }
+  if (internalState == InternalState::STARTUP) {
+    commandExecuted = true;
+  }
+  PoolReadGuard pg(&dataset);
+  // Simple FDIR variant to make the handler more robust to invalid messages which
+  // appear sometimes for the SUS device: Allow invalid message up to a certain threshold
+  // before triggering FDIR reactions.
+  if (reply->tempRaw == 0xfff and not waitingForRecovery) {
+    if (invalidMsgCounter == 0) {
+      triggerEvent(TEMPERATURE_ALL_ONES_START);
+    } else if (invalidMsgCounter == susMax1227::MAX_INVALID_MSG_COUNT) {
+      triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT);
+      waitingForRecovery = true;
+    }
+    invalidMsgCounter++;
+    dataset.setValidity(false, true);
+    dataset.tempC = thermal::INVALID_TEMPERATURE;
+    std::memset(dataset.channels.value, 0, sizeof(dataset.channels.value));
+    return returnvalue::OK;
+  }
+  if (invalidMsgCounter > 0) {
+    triggerEvent(TEMPERATURE_ALL_ONES_RECOVERY, invalidMsgCounter);
+    invalidMsgCounter = 0;
+  }
+  dataset.setValidity(true, true);
+  dataset.tempC = max1227::getTemperature(reply->tempRaw);
+  std::memcpy(dataset.channels.value, reply->channelsRaw, sizeof(reply->channelsRaw));
   return returnvalue::OK;
 }
 

mission/acs/SusHandler.h

@@ -15,7 +15,15 @@ class SusHandler : public DeviceHandlerBase {
   static constexpr DeviceCommandId_t REPLY = 0x77;
 
   static const uint8_t INTERFACE_ID = CLASS_ID::SUS_HANDLER;
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SUS_BOARD_ASS;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SUS_HANDLER;
+
+  //! [EXPORT] : [COMMENT] Detected invalid values, starting invalid message counting
+  static constexpr Event TEMPERATURE_ALL_ONES_START =
+      event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] Detected valid values again, resetting invalid message counter.
+  //! P1: Invalid message counter.
+  static constexpr Event TEMPERATURE_ALL_ONES_RECOVERY =
+      event::makeEvent(SUBSYSTEM_ID, 1, severity::INFO);
 
   SusHandler(uint32_t objectId, uint8_t susIdx, object_id_t deviceCommunication,
              CookieIF *comCookie);
@@ -46,6 +54,8 @@ class SusHandler : public DeviceHandlerBase {
   susMax1227::SusDataset dataset;
   acs::SusRequest request{};
   uint8_t susIdx;
+  bool waitingForRecovery = true;
+  uint32_t invalidMsgCounter = 0;
 
   uint32_t transitionDelay = 1000;
   bool goToNormalMode = false;

mission/acs/archive/GPSDefinitions.h

@@ -20,32 +20,47 @@ static constexpr Event CANT_GET_FIX = event::makeEvent(SUBSYSTEM_ID, 1, severity
 static constexpr DeviceCommandId_t GPS_REPLY = 0;
 static constexpr DeviceCommandId_t TRIGGER_RESET_PIN_GNSS = 5;
 
-static constexpr uint32_t DATASET_ID = 0;
+enum SetIds : uint32_t {
+  CORE_DATASET,
+  SKYVIEW_DATASET,
+};
 
 enum GpsPoolIds : lp_id_t {
-  LATITUDE = 0,
-  LONGITUDE = 1,
-  ALTITUDE = 2,
-  SPEED = 3,
-  FIX_MODE = 4,
-  SATS_IN_USE = 5,
-  SATS_IN_VIEW = 6,
-  UNIX_SECONDS = 7,
-  YEAR = 8,
-  MONTH = 9,
-  DAY = 10,
-  HOURS = 11,
-  MINUTES = 12,
-  SECONDS = 13
+  LATITUDE,
+  LONGITUDE,
+  ALTITUDE,
+  SPEED,
+  FIX_MODE,
+  SATS_IN_USE,
+  SATS_IN_VIEW,
+  UNIX_SECONDS,
+  YEAR,
+  MONTH,
+  DAY,
+  HOURS,
+  MINUTES,
+  SECONDS,
+  SKYVIEW_UNIX_SECONDS,
+  PRN_ID,
+  AZIMUTH,
+  ELEVATION,
+  SIGNAL2NOISE,
+  USED,
 };
 
+static constexpr uint8_t CORE_DATASET_ENTRIES = 14;
+static constexpr uint8_t SKYVIEW_ENTRIES = 6;
+
+static constexpr uint8_t MAX_SATELLITES = 30;
+
 enum GpsFixModes : uint8_t { INVALID = 0, NO_FIX = 1, FIX_2D = 2, FIX_3D = 3 };
 
 }  // namespace GpsHyperion
 
-class GpsPrimaryDataset : public StaticLocalDataSet<18> {
+class GpsPrimaryDataset : public StaticLocalDataSet<GpsHyperion::CORE_DATASET_ENTRIES> {
  public:
-  GpsPrimaryDataset(object_id_t gpsId) : StaticLocalDataSet(sid_t(gpsId, GpsHyperion::DATASET_ID)) {
+  GpsPrimaryDataset(object_id_t gpsId)
+      : StaticLocalDataSet(sid_t(gpsId, GpsHyperion::CORE_DATASET)) {
     setAllVariablesReadOnly();
   }
 
@@ -69,7 +84,34 @@ class GpsPrimaryDataset : public StaticLocalDataSet<18> {
   friend class GpsHyperionLinuxController;
   friend class GpsCtrlDummy;
   GpsPrimaryDataset(HasLocalDataPoolIF* hkOwner)
-      : StaticLocalDataSet(hkOwner, GpsHyperion::DATASET_ID) {}
+      : StaticLocalDataSet(hkOwner, GpsHyperion::CORE_DATASET) {}
+};
+
+class SkyviewDataset : public StaticLocalDataSet<GpsHyperion::SKYVIEW_ENTRIES> {
+ public:
+  SkyviewDataset(object_id_t gpsId)
+      : StaticLocalDataSet(sid_t(gpsId, GpsHyperion::SKYVIEW_DATASET)) {
+    setAllVariablesReadOnly();
+  }
+
+  lp_var_t<double> unixSeconds =
+      lp_var_t<double>(sid.objectId, GpsHyperion::SKYVIEW_UNIX_SECONDS, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> prn_id =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::PRN_ID, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> azimuth =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::AZIMUTH, this);
+  lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES> elevation =
+      lp_vec_t<int16_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::ELEVATION, this);
+  lp_vec_t<double, GpsHyperion::MAX_SATELLITES> signal2noise =
+      lp_vec_t<double, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::SIGNAL2NOISE, this);
+  lp_vec_t<uint8_t, GpsHyperion::MAX_SATELLITES> used =
+      lp_vec_t<uint8_t, GpsHyperion::MAX_SATELLITES>(sid.objectId, GpsHyperion::USED, this);
+
+ private:
+  friend class GpsHyperionLinuxController;
+  friend class GpsCtrlDummy;
+  SkyviewDataset(HasLocalDataPoolIF* hkOwner)
+      : StaticLocalDataSet(hkOwner, GpsHyperion::SKYVIEW_DATASET) {}
 };
 
 #endif /* MISSION_ACS_ARCHIVE_GPSDEFINITIONS_H_ */

mission/acs/defs.h

@@ -26,14 +26,29 @@ enum SafeModeStrategy : uint8_t {
   SAFECTRL_OFF = 0,
   SAFECTRL_NO_MAG_FIELD_FOR_CONTROL = 1,
   SAFECTRL_NO_SENSORS_FOR_CONTROL = 2,
-  SAFECTRL_ACTIVE_MEKF = 10,
-  SAFECTRL_WITHOUT_MEKF = 11,
-  SAFECTRL_ECLIPSE_DAMPING = 12,
-  SAFECTRL_ECLIPSE_IDELING = 13,
+  // OBSW version <= v6.1.0
+  LEGACY_SAFECTRL_ACTIVE_MEKF = 10,
+  LEGACY_SAFECTRL_WITHOUT_MEKF = 11,
+  LEGACY_SAFECTRL_ECLIPSE_DAMPING = 12,
+  LEGACY_SAFECTRL_ECLIPSE_IDELING = 13,
+  // Added in v6.2.0
+  SAFECTRL_MEKF = 14,
+  SAFECTRL_GYR = 15,
+  SAFECTRL_SUSMGM = 16,
+  SAFECTRL_ECLIPSE_DAMPING_GYR = 17,
+  SAFECTRL_ECLIPSE_DAMPING_SUSMGM = 18,
+  SAFECTRL_ECLIPSE_IDELING = 19,
   SAFECTRL_DETUMBLE_FULL = 20,
   SAFECTRL_DETUMBLE_DETERIORATED = 21,
 };
 
+enum GpsSource : uint8_t {
+  NONE,
+  GPS,
+  GPS_EXTRAPOLATED,
+  SPG4,
+};
+
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;
 //! [EXPORT] : [COMMENT] The limits for the rotation in safe mode were violated.
 static constexpr Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);
@@ -56,6 +71,8 @@ static constexpr Event MEKF_INVALID_MODE_VIOLATION = MAKE_EVENT(6, severity::HIG
 //! failed.
 //! P1: Missing information about magnetic field, P2: Missing information about rotational rate
 static constexpr Event SAFE_MODE_CONTROLLER_FAILURE = MAKE_EVENT(7, severity::HIGH);
+//! [EXPORT] : [COMMENT] The TLE for the SGP4 Propagator has become too old.
+static constexpr Event TLE_TOO_OLD = MAKE_EVENT(8, severity::INFO);
 
 extern const char* getModeStr(AcsMode mode);
 

mission/acs/str/StarTrackerHandler.cpp

@@ -1,3 +1,4 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/StarTrackerHandler.h>
@@ -18,6 +19,7 @@ extern "C" {
 
 #include "OBSWConfig.h"
 #include "eive/definitions.h"
+#include "fsfw/thermal/tcsDefinitions.h"
 
 std::atomic_bool JCFG_DONE(false);
 
@@ -87,7 +89,6 @@ void StarTrackerHandler::doStartUp() {
     default:
       return;
   }
-  solutionSet.setReportingEnabled(true);
   startupState = StartupState::DONE;
   internalState = InternalState::IDLE;
   setMode(_MODE_TO_ON);
@@ -111,6 +112,9 @@ void StarTrackerHandler::doShutDown() {
   }
   {
     PoolReadGuard pg(&temperatureSet);
+    temperatureSet.fpgaTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.cmosTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.mcuTemperature = thermal::INVALID_TEMPERATURE;
     temperatureSet.setValidity(false, true);
   }
   reinitNextSetParam = false;
@@ -321,7 +325,7 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
 ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
   switch (internalState) {
     case InternalState::BOOT_FIRMWARE: {
-      if (bootState == FwBootState::WAIT_FOR_EXECUTION or bootState == FwBootState::VERIFY_BOOT) {
+      if (bootState == FwBootState::VERIFY_BOOT or isAwaitingReply()) {
         return NOTHING_TO_SEND;
       }
       if (bootState == FwBootState::NONE) {
@@ -345,74 +349,69 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
           *id = startracker::REQ_VERSION;
           return buildCommandFromCommand(*id, nullptr, 0);
         }
+        case (FwBootState::SET_TIME): {
+          *id = startracker::SET_TIME_FROM_SYS_TIME;
+          return buildCommandFromCommand(*id, nullptr, 0);
+        }
         case (FwBootState::LOGLEVEL): {
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::LOGLEVEL;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         }
         case (FwBootState::LIMITS): {
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::LIMITS;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         }
         case (FwBootState::TRACKING): {
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::TRACKING;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         }
         case FwBootState::MOUNTING:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::MOUNTING;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::IMAGE_PROCESSOR:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::IMAGE_PROCESSOR;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::CAMERA:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::CAMERA;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::CENTROIDING:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::CENTROIDING;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::LISA:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::LISA;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::MATCHING:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::MATCHING;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::VALIDATION:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::VALIDATION;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::ALGO:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::ALGO;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::LOG_SUBSCRIPTION:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::LOGSUBSCRIPTION;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         case FwBootState::DEBUG_CAMERA:
-          bootState = FwBootState::WAIT_FOR_EXECUTION;
           *id = startracker::DEBUG_CAMERA;
           return buildCommandFromCommand(
               *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
+        case FwBootState::AUTO_THRESHOLD:
+          *id = startracker::AUTO_THRESHOLD;
+          return buildCommandFromCommand(
+              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
         default: {
           sif::error << "STR: Unexpected boot state" << (int)bootState << std::endl;
           return NOTHING_TO_SEND;
@@ -455,6 +454,20 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       preparePingRequest();
       return returnvalue::OK;
     }
+    case (startracker::SET_TIME_FROM_SYS_TIME): {
+      SetTimeActionRequest setTimeRequest{};
+      timeval tv;
+      Clock::getClock(&tv);
+      setTimeRequest.unixTime =
+          (static_cast<uint64_t>(tv.tv_sec) * 1000 * 1000) + (static_cast<uint64_t>(tv.tv_usec));
+      arc_pack_settime_action_req(&setTimeRequest, commandBuffer, &rawPacketLen);
+      size_t serLen = 0;
+      // Time in milliseconds. Manual serialization because arcsec API ignores endianness.
+      SerializeAdapter::serialize(&setTimeRequest.unixTime, commandBuffer + 2, &serLen,
+                                  sizeof(commandBuffer) - 2, SerializeIF::Endianness::LITTLE);
+      rawPacket = commandBuffer;
+      return returnvalue::OK;
+    }
     case (startracker::REQ_TIME): {
       prepareTimeRequest();
       return returnvalue::OK;
@@ -547,6 +560,11 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel, reinitNextSetParam);
       return result;
     }
+    case (startracker::AUTO_THRESHOLD): {
+      result =
+          prepareParamCommand(commandData, commandDataLen, jcfgs.autoThreshold, reinitNextSetParam);
+      return result;
+    }
     case (startracker::LOGSUBSCRIPTION): {
       result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription,
                                    reinitNextSetParam);
@@ -651,19 +669,23 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::LOGLEVEL, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::SET_TIME_FROM_SYS_TIME, 2, nullptr,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::LOGSUBSCRIPTION, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::DEBUG_CAMERA, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::LIMITS, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::AUTO_THRESHOLD, 2, nullptr,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::MOUNTING, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::IMAGE_PROCESSOR, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
-  this->insertInCommandAndReplyMap(startracker::CENTROIDING, 3, nullptr,
+  this->insertInCommandAndReplyMap(startracker::CENTROIDING, 2, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::LISA, 3, nullptr,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
@@ -810,6 +832,7 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) {
         setMode(toMode, startracker::SUBMODE_FIRMWARE);
       }
       sif::info << "STR: Firmware boot success" << std::endl;
+      solutionSet.setReportingEnabled(true);
       internalState = InternalState::IDLE;
       startupState = StartupState::IDLE;
       break;
@@ -833,6 +856,7 @@ void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonF
   cfgs.mounting.init(paramJsonFile);
   cfgs.limits.init(paramJsonFile);
   cfgs.subscription.init(paramJsonFile);
+  cfgs.autoThreshold.init(paramJsonFile);
   JCFG_DONE = true;
 }
 
@@ -856,13 +880,20 @@ ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t rema
     *foundLen = remainingSize;
     return returnvalue::OK;
   }
-  if (remainingSize < 3) {
-    sif::error << "StarTrackerHandler: Reply packet with length less than 3 is invalid"
+  if (remainingSize < 2) {
+    sif::error << "StarTrackerHandler: Reply packet with length " << remainingSize
+               << "  less than "
+                  "2 is invalid"
                << std::endl;
     return returnvalue::FAILED;
   }
 
   switch (startracker::getReplyFrameType(start)) {
+    case TMTC_COMM_ERROR: {
+      *foundLen = remainingSize;
+      triggerEvent(COM_ERROR_REPLY_RECEIVED, start[1]);
+      break;
+    }
     case TMTC_ACTIONREPLY: {
       *foundLen = remainingSize;
       return scanForActionReply(startracker::getId(start), foundId);
@@ -897,6 +928,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
   ReturnValue_t result = returnvalue::OK;
 
   switch (id) {
+    case (startracker::SET_TIME_FROM_SYS_TIME): {
+      result = handleActionReply(packet);
+      break;
+    }
     case (startracker::REQ_TIME): {
       result = handleTm(packet, timeSet, startracker::TimeSet::SIZE, "REQ_TIME");
       break;
@@ -956,7 +991,8 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
     case (startracker::TRACKING):
     case (startracker::VALIDATION):
     case (startracker::IMAGE_PROCESSOR):
-    case (startracker::ALGO): {
+    case (startracker::ALGO):
+    case (startracker::AUTO_THRESHOLD): {
       result = handleSetParamReply(packet);
       break;
     }
@@ -1363,6 +1399,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(uint8_t replyId, DeviceComm
       *foundId = startracker::UPLOAD_IMAGE;
       break;
     }
+    case (ARC_ACTION_REQ_SETTIME_ID): {
+      *foundId = startracker::SET_TIME_FROM_SYS_TIME;
+      break;
+    }
     case (startracker::ID::CHECKSUM): {
       *foundId = startracker::CHECKSUM;
       break;
@@ -1430,6 +1470,10 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(uint8_t replyId,
       *foundId = startracker::DEBUG_CAMERA;
       break;
     }
+    case (startracker::ID::AUTO_THRESHOLD): {
+      *foundId = startracker::AUTO_THRESHOLD;
+      break;
+    }
     case (startracker::ID::LOG_SUBSCRIPTION): {
       *foundId = startracker::LOGSUBSCRIPTION;
       break;
@@ -1857,7 +1901,7 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
   uint8_t status = startracker::getStatusField(rawFrame);
   if (status != startracker::STATUS_OK) {
     sif::warning << "StarTrackerHandler::handleSetParamReply: Failed to execute parameter set "
-                    " command with parameter ID"
+                    "command with parameter ID "
                  << static_cast<unsigned int>(*(rawFrame + PARAMETER_ID_OFFSET)) << std::endl;
     if (internalState != InternalState::IDLE) {
       internalState = InternalState::IDLE;
@@ -1865,21 +1909,25 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
     return SET_PARAM_FAILED;
   }
   if (internalState != InternalState::IDLE) {
-    handleStartup(*(rawFrame + PARAMETER_ID_OFFSET));
+    handleStartup(*rawFrame, *(rawFrame + PARAMETER_ID_OFFSET));
   }
   return returnvalue::OK;
 }
 
 ReturnValue_t StarTrackerHandler::handleActionReply(const uint8_t* rawFrame) {
   uint8_t status = startracker::getStatusField(rawFrame);
+  ReturnValue_t result = returnvalue::OK;
   if (status != startracker::STATUS_OK) {
     sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action "
                  << "command with action ID "
                  << static_cast<unsigned int>(*(rawFrame + ACTION_ID_OFFSET)) << " and status "
                  << static_cast<unsigned int>(status) << std::endl;
-    return ACTION_FAILED;
+    result = ACTION_FAILED;
   }
-  return returnvalue::OK;
+  if (internalState != InternalState::IDLE) {
+    handleStartup(*rawFrame, *(rawFrame + PARAMETER_ID_OFFSET));
+  }
+  return result;
 }
 
 ReturnValue_t StarTrackerHandler::handleChecksumReply(const uint8_t* rawFrame) {
@@ -1975,7 +2023,7 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
         startupState = StartupState::BOOT_BOOTLOADER;
       }
       if (bootState == FwBootState::VERIFY_BOOT) {
-        bootState = FwBootState::LOGLEVEL;
+        bootState = FwBootState::SET_TIME;
       } else if (internalState == InternalState::BOOTLOADER_CHECK) {
         triggerEvent(BOOTING_BOOTLOADER_FAILED_EVENT);
         internalState = InternalState::FAILED_BOOTLOADER_BOOT;
@@ -2052,7 +2100,18 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(const uint8_t* rawFrame,
   return result;
 }
 
-void StarTrackerHandler::handleStartup(uint8_t parameterId) {
+void StarTrackerHandler::handleStartup(uint8_t tmType, uint8_t parameterId) {
+  switch (tmType) {
+    case (TMTC_ACTIONREPLY): {
+      case (ARC_ACTION_REQ_SETTIME_ID): {
+        bootState = FwBootState::LOGLEVEL;
+        return;
+      }
+      default: {
+        break;
+      }
+    }
+  }
   switch (parameterId) {
     case (startracker::ID::LOG_LEVEL): {
       bootState = FwBootState::LIMITS;
@@ -2062,7 +2121,7 @@ void StarTrackerHandler::handleStartup(uint8_t parameterId) {
       bootState = FwBootState::TRACKING;
       break;
     }
-    case (startracker::ID::TRACKING): {
+    case (ARC_PARAM_TRACKING_ID): {
       bootState = FwBootState::MOUNTING;
       break;
     }
@@ -2103,6 +2162,10 @@ void StarTrackerHandler::handleStartup(uint8_t parameterId) {
       break;
     }
     case (startracker::ID::DEBUG_CAMERA): {
+      bootState = FwBootState::AUTO_THRESHOLD;
+      break;
+    }
+    case (startracker::ID::AUTO_THRESHOLD): {
       bootState = FwBootState::NONE;
       internalState = InternalState::DONE;
       break;

mission/acs/str/StarTrackerHandler.h

@@ -6,6 +6,7 @@
 #include <mission/acs/str/ArcsecJsonParamBase.h>
 #include <mission/acs/str/strHelpers.h>
 #include <mission/acs/str/strJsonCommands.h>
+#include <thirdparty/sagittactl/wire/common/genericstructs.h>
 
 #include <thread>
 
@@ -16,7 +17,7 @@
 #include "fsfw/timemanager/Countdown.h"
 
 extern "C" {
-#include <wire/common/SLIP.h>
+#include <wire/common/genericstructs.h>
 }
 
 /**
@@ -143,6 +144,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
   static const Event BOOTING_FIRMWARE_FAILED_EVENT = MAKE_EVENT(1, severity::LOW);
   //! [EXPORT] : [COMMENT] Failed to boot star tracker into bootloader mode
   static const Event BOOTING_BOOTLOADER_FAILED_EVENT = MAKE_EVENT(2, severity::LOW);
+  //! [EXPORT] : [COMMENT] Received COM error. P1:  Communication Error ID (datasheet p32)
+  static constexpr Event COM_ERROR_REPLY_RECEIVED = MAKE_EVENT(3, severity::LOW);
 
   static const uint8_t STATUS_OFFSET = 2;
   static const uint8_t PARAMS_OFFSET = 2;
@@ -226,6 +229,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
     Mounting mounting;
     Limits limits;
     Subscription subscription;
+    AutoThreshold autoThreshold;
   };
   JsonConfigs jcfgs;
   Countdown jcfgCountdown = Countdown(250);
@@ -264,6 +268,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
     BOOT_DELAY,
     REQ_VERSION,
     VERIFY_BOOT,
+    SET_TIME,
     LOGLEVEL,
     LIMITS,
     TRACKING,
@@ -278,7 +283,9 @@ class StarTrackerHandler : public DeviceHandlerBase {
     ALGO,
     LOG_SUBSCRIPTION,
     DEBUG_CAMERA,
+    AUTO_THRESHOLD,
     WAIT_FOR_EXECUTION,
+    RETRY_CFG_CMD
   };
   FwBootState bootState = FwBootState::NONE;
 
@@ -468,7 +475,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
   /**
    * @brief   Handles the startup state machine
    */
-  void handleStartup(uint8_t parameterId);
+  void handleStartup(uint8_t tmType, uint8_t parameterId);
 
   /**
    * @brief   Handles telemtry replies and fills the appropriate dataset

mission/acs/str/arcsecJsonKeys.h

@@ -176,6 +176,13 @@ static const char DEBUG_CAMERA[] = "DebugCamera";
 static const char TIMING[] = "timing";
 static const char TEST[] = "test";
 
+static constexpr char AUTO_THRESHOLD[] = "AutoThreshold";
+static constexpr char AT_MODE[] = "mode";
+static constexpr char AT_DESIRED_BLOB_COUNTS[] = "desiredBlobsCount";
+static constexpr char AT_MIN_THRESHOLD[] = "minThreshold";
+static constexpr char AT_MAX_THRESHOLD[] = "maxThreshold";
+static constexpr char AT_THRESHOLD_KP[] = "thresholdKp";
+
 }  // namespace arcseckeys
 
 #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */

mission/acs/str/strHelpers.h

@@ -326,6 +326,8 @@ static const DeviceCommandId_t DEBUG_CAMERA = 83;
 static const DeviceCommandId_t FIRMWARE_UPDATE = 84;
 static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
 static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
+static constexpr DeviceCommandId_t SET_TIME_FROM_SYS_TIME = 87;
+static constexpr DeviceCommandId_t AUTO_THRESHOLD = 88;
 static const DeviceCommandId_t NONE = 0xFFFFFFFF;
 
 static const uint32_t VERSION_SET_ID = REQ_VERSION;
@@ -396,7 +398,6 @@ static const uint8_t ALGO = 16;
 static const uint8_t REBOOT = 7;
 static const uint8_t UPLOAD_IMAGE = 10;
 static const uint8_t POWER = 11;
-static const uint8_t SET_TIME = 14;
 static const uint8_t SUBSCRIPTION = 18;
 static const uint8_t SOLUTION = 24;
 static const uint8_t TEMPERATURE = 27;
@@ -410,6 +411,7 @@ static const uint8_t TAKE_IMAGE = 15;
 static const uint8_t LOG_LEVEL = 3;
 static const uint8_t LOG_SUBSCRIPTION = 19;
 static const uint8_t DEBUG_CAMERA = 20;
+static const uint8_t AUTO_THRESHOLD = 23;
 }  // namespace ID
 
 namespace Program {
@@ -441,6 +443,21 @@ static const uint32_t secret[16]{
     REGION_12_SECRET, REGION_13_SECRET, REGION_14_SECRET, REGION_15_SECRET};
 }  // namespace region_secrets
 
+namespace comError {
+enum Id {
+  BAD_CRC = 1,
+  UNKNOWN_TM_ID = 2,
+  UNKNOWN_PARAM_ID = 3,
+  UNKNOWN_ACTION_REQ = 4,
+  INVALID_TM_SIZE = 5,
+  INVALID_PARAM_SIZE = 6,
+  INVALID_ACTION_REQ_SIZE = 7,
+  FRAME_TOO_SHORT = 8,
+  INVALID_FRAME_TYPE = 9,
+  UNKNOWN_ERROR = 10
+};
+}
+
 enum class FlashSections : uint8_t {
   BOOTLOADER_SECTION = 0,
   MAIN_FIRMWARE_SECTION = 1,
@@ -650,7 +667,7 @@ class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
   // Ticks timestamp
   lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_SOLUTION_SET, this);
   /// Unix time stamp
-  lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
   // Calibrated quaternion (takes into account the mounting quaternion), typically same as
   // track q values
   lp_var_t<float> caliQw = lp_var_t<float>(sid.objectId, PoolIds::CALI_QW, this);
@@ -695,7 +712,7 @@ class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
   void printSet() {
     PoolReadGuard rg(this);
     sif::info << "SolutionSet::printSet: Ticks: " << this->ticks << std::endl;
-    sif::info << "SolutionSet::printSet: Time: " << this->time << std::endl;
+    sif::info << "SolutionSet::printSet: Time: " << this->timeUs << std::endl;
     sif::info << "SolutionSet::printSet: Calibrated quaternion Qw: " << this->caliQw << std::endl;
     sif::info << "SolutionSet::printSet: Calibrated quaternion Qx: " << this->caliQx << std::endl;
     sif::info << "SolutionSet::printSet: Calibrated quaternion Qy: " << this->caliQy << std::endl;

mission/acs/str/strJsonCommands.cpp

@@ -916,3 +916,45 @@ ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) {
   adduint32(param, buffer + offset);
   return returnvalue::OK;
 }
+
+AutoThreshold::AutoThreshold() : ArcsecJsonParamBase(arcseckeys::AUTO_THRESHOLD) {}
+
+size_t AutoThreshold::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t AutoThreshold::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::AUTO_THRESHOLD);
+  offset = 2;
+  result = getParam(arcseckeys::AT_MODE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += 1;
+  result = getParam(arcseckeys::AT_DESIRED_BLOB_COUNTS, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += 1;
+  result = getParam(arcseckeys::AT_MIN_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint16(param, buffer + offset);
+  offset += 2;
+  result = getParam(arcseckeys::AT_MAX_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint16(param, buffer + offset);
+  offset += 2;
+  result = getParam(arcseckeys::AT_THRESHOLD_KP, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  return returnvalue::OK;
+}

mission/acs/str/strJsonCommands.h

@@ -222,6 +222,22 @@ class LogSubscription : public ArcsecJsonParamBase {
   ReturnValue_t createCommand(uint8_t* buffer) override;
 };
 
+/**
+ * @brief   Generates command to set log subscription parameters.
+ *
+ */
+class AutoThreshold : public ArcsecJsonParamBase {
+ public:
+  AutoThreshold();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 12;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
 /**
  * @brief   Generates command to set debug camera parameters
  *