Merge pull request 'the hottest fix' (#614) from hottest_fix_acs into main

Reviewed-on: #614

.gitmodules

@@ -10,9 +10,6 @@
 [submodule "thirdparty/lwgps"]
 	path = thirdparty/lwgps
 	url = https://github.com/rmspacefish/lwgps.git
-[submodule "thirdparty/arcsec_star_tracker"]
-	path = thirdparty/arcsec_star_tracker
-	url = https://egit.irs.uni-stuttgart.de/eive/arcsec_star_tracker.git
 [submodule "thirdparty/json"]
 	path = thirdparty/json
 	url = https://github.com/nlohmann/json.git
@@ -22,3 +19,6 @@
 [submodule "thirdparty/gomspace-sw"]
 	path = thirdparty/gomspace-sw
 	url = https://egit.irs.uni-stuttgart.de/eive/gomspace-sw.git
+[submodule "thirdparty/sagittactl"]
+	path = thirdparty/sagittactl
+	url = https://egit.irs.uni-stuttgart.de/eive/sagittactl.git

.idea/cmake.xml

@@ -2,7 +2,6 @@
 <project version="4">
   <component name="CMakeSharedSettings">
     <configurations>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" NO_GENERATOR="true" />
       <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Q7S" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
         <ADDITIONAL_GENERATION_ENVIRONMENT>
           <envs>

CHANGELOG.md

@@ -16,10 +16,286 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v2.0.4] 2023-04-19
+
+## Fixed
+
+- The dual lane assembly device handlers did not properly set their datasets
+  to invalid on off transitions
+
+# [v2.0.3] 2023-04-17
+
+- eive-tmtc: v3.1.1
+
+## Fixed
+
+- Fixed shadowing within the `SafeCtrl`, which prevented actuator commands to be calculated during
+  eclipse phase.
+- EM build idle mode fixes for RW dummy.
+
+## Added
+
+- Add `MGT_OVERHEATING` event and fallback to system SAFE mode if the MGT is overheating for
+  whatever reason.
+
+## Changed
+
+- Low-pass filters can no longer be executed if no actual data is available.
+
+# [v2.0.2] 2023-04-16
+
+- Bump patch version to 2.
+
+# [v2.0.1] 2023-04-16
+
+- eive-tmtc: v3.1.0
+
+# [v2.0.0] 2023-04-16
+
+This is the version which will fly on the satellite for the initial launch phase.
+
+- q7s-package: v2.5.0
+- eive-tmtc: v3.0.0
+- `wire` library is now on version v10.7 as well.
+
+## Added
+
+- Added `mv`, `cp` and `rm` action helpers for the core controller for common filesystem operations.
+- Extended directory listing helpers. There is now a directory listing helper which dumps the
+  directory listing as an action data reply immediately. For smaller directory listings, this
+  allows a listing without requiring a separate file downlink (which also has not been implemented
+  yet)
+
+## Changed
+
+- The directory listing action commands now allow compressing of either the target output file
+  for the directory listing into file action command, or compression in the helper which dumps
+  the directory listing directly.
+
+# [v1.45.0] 2023-04-14
+
+- q7s-package: v2.5.0
+- eive-tmtc: v3.0.0
+- STR firmware was updated to v10.7. `wire` library still needs to be updated.
+
+## Fixed
+
+- Small fix for `install-obsw-yocto.sh` script
+- Bugfix for STR firmware update procedure where the last remaining
+  bytes were not written properly.
+- Bugfix for STR where an invalid reply was received for special requests
+  like firmware updates.
+- Bugfix for shell command executors in command controller which lead to a crash.
+- Important bugfix for STR solution set. Missing STR mode u8 parameter.
+- Fix for STR image download.
+- Possible fix for STR image upload.
+- Fixed regression where the reply result for ACS board and SUS board devices was set to FAILED
+  even when going to OFF mode. In that case, it has to be set to OK so the device handler can
+  complete the OFF transition.
+
+## Changed
+
+- STR `wire` library updated to v10.3. Submodule renamed to `sagittactl`.
+- Custom FDIR for TMP1075 sensors. The device handlers reject `NEEDS_RECOVERY` health commands
+  anyway, so it does not really make sense to use the default FDIR.
+- Reject `NEEDS_RECOVERY` health commands for the heater health devices.
+- Adapted some queue sizes so that EM startup works without queue errors
+  - Event Manager: 120 -> 160
+  - UDP TMTC Bridge: 50 -> 120
+  - TCP TMTC Bridge: 50 -> 120
+  - Service 5: 120 -> 160, number of events handled in one cycle increased to 80
+- EM: PCDU dummy is not a device handler anymore, but a custom power switcher object. This avoids
+  some issues where the event manager could not send an event message to the PCDU dummy because
+  the FDIR event queue was too small.
+
+## Added
+
+- Add a way for the MAX31865 RTD handlers to recognize faulty/broken/off sensor devices.
+- Add parameter interface for core controller
+- Allow setting the preferred SD card via the new parameter interface of the core controller
+  with domain ID 0 and unque ID 0.
+- Added action commands to reset the PDEC. Also added autonomous reset handling for the PDEC,
+  because there is no way so send TCs with a faulty PDEC.
+- Added `I2C_REBOOT` and `PDEC_REBOOT` events for EIVE system component to ensure ground gets
+  informed.
+
+## ACS
+
+- Commanding from ACS Controller is now enabled.
+- Safe Controller was reverted to FLP Design. This also introduces safe mode strategies.
+  They contain what the controller does and which data it uses. The controller will
+  automatically based on the available data decide on which strategy to use. If a strategy
+  is undesirable (e.g. the MEKF should not be used) this can be handeld via setting parameters.
+
+# [v1.44.1] 2023-04-12
+
+- eive-tmtc: v2.22.1
+
+## Fixed
+
+- Bugfixes and improvements for SDC state machine. Internal state was not updated correctly due
+  to a regression, so commanding the SDC state machine externally lead to confusing results.
+- Heater states array in TCS controller was too small.
+- Fixed a bug in persistent TM store, where the active file was not reset of SD card switches.
+  SD card switch from 0 to 1 and vice-versa works without errors from persistent TM stores now.
+- Add a way for the SUS polling to detect broken or off devices by checking the retrieved
+  temperature for the all-ones value (0x0fff).
+- Better reply result handling for the ACS board devices.
+- ADIS1650X initial timeout handling now performed in device handler.
+- The RW assembly and TCS board assembly now perform proper power switch handling for their
+  recovery handling.
+
+## Changed
+
+- Added additional logic for SDC state machine so that the SD cards are marked unusable when
+  the active SD card is switched or there is a transition from hot redundant to cold redundant mode.
+  This gives other tasks some time to register the SD cards being unusable, and therefore provides
+  a way for them to perform any re-initialization tasks necessary after SD card switches.
+- TCS controller now only has an OFF mode and an ON mode
+- The TCS controller pauses operations related to the TCS board assembly (reading sensors and 
+  the primary control loop) while a TCS board recovery is on-going.
+- Allow specifying custom OBSW update filename. This allowed keeping a cleaner file structure
+  where each update has a name including the version
+- The files extracted during an update process are deleted after the update was performed to keep
+  the update directory cleaner.
+
+## Added
+
+- TCS controller: SUBMODE_NO_HEATER_CTRL (1) added for ON mode. If this submode is
+  commanded, all heaters will be switched off and then no further heater
+  commanding will be done.
+- Fixed a bug in persistent TM store, where the active file was not reset of SD card switches.
+  SD card switch from 0 to 1 and vice-versa works without errors from persistent TM stores now.
+
+# [v1.44.0] 2023-04-07
+
+- eive-tmtc: v2.22.0
+
+## Added
+
+- Special I2C recovery handling. If the I2C bus is unavailable for whatever reason, the EIVE
+  system component will power-cycle all I2C devices by first going to the OFF/BOOT mode, then
+  power-cycling the 3V3 stack and rebooting the battery, and finally going back to safe mode.
+  If this does not restore the bus, a full reboot will be performed. This special sequence can
+  be commanded as well.
+
+## Fixed
+
+- RW Assembly: Correctly transition back to off when more than 1 devices is OFF. Also do this
+  when this was due to two devices being marked faulty.
+- RW dummy and STR dummy components: Set/Update modes correctly.
+- RW handlers: Bugfix for TM set retrieval and special request handling in general where the CRC
+  check always failed for special request. Also removed an unnecessary delay for special requests.
+- RW handlers: Polling is now disabled for RWs which are off.
+
+## Changed
+
+- RW shutdown now waits for the speed to be near 0 or for a OFF transition countdown to be expired
+  before going to off.
+
+# [v1.43.2] 2023-04-05
+
+## Changed
+
+- Adapted HK data rates to new table for LEOP SAFE mode.
+- GPS controller HK is now generated periodically as well.
+- Better mode combination checks for assembly components. This includes:
+  - IMTQ assembly
+  - Syrlinks assembly
+  - Dual Lane Assembly
+- RWs are no longer commanded by the ACS Controller during safe mode. Instead the RW speed command
+  is set to 0 as part or the `doShutDown` of the RW handler.
+
+## Fixed
+
+- Dual lane assemblies: Fix handling when health states are overwritten. Also add better handling
+  when some devices are permanent faulty and some are only faulty. In that case, only the faulty
+  devices will be restored.
+- ACS dual lane assembly: Gyro 3 helper mode was assigned to the Gyro 2 mode.
+
+# [v1.43.1] 2023-04-04
+
+## Fixed
+
+- Generic HK handling: Bug where HKs were generated a lot more often than required. This is the case
+  if a device handler `PERFORM_OPERATION` step is performed more than once per PST cycle.
+- Syrlinks now goes to `_MODE_TO_ON` when finishing the `doStartUp` transition.
+
+## Changed
+
+- Doubled GS PST interval instead of scheduling everything twice.
+- Syrlinks now only has one `PERFORM_OPERATION` step, but still has two communication steps.
+- PCDU components only allow setting `NEEDS_RECOVERY`, `HEALTHY` and `EXTERNAL_CONTROL` health
+  states now. TMP sensor components only allow `HEALTHY` , `EXTERNAL_CONTROL`, `FAULTY` and
+  `PERMANENT_FAULTY`.
+- TCS controller now does a sanity check on the temperature values: Values below -80 C or above
+  160 C are ignored.
+
+# [v1.43.0] 2023-04-04
+
+- q7s-package: v2.4.0
+- eive-tmtc: v2.21.0
+
+## Added
+
+- Version of thermal controller which performs basic control tasks.
+- PCDU handler can now command switch of the 3V3 stack (switch ID 19)
+- Set STR dev to OFF in assembly when it is faulty.
+- STR: Reset data link layer and flush RX for regular commands and before performing special
+  commands to ensure consistent start state
+
+## Fixed
+
+- PTME was not reset after configuration changes.
+- GPS health devices: ACS board assembly not reacts to health changes.
+- STR COM helper: Reset reply size after returning a reply
+
+## Changed
+
+- Poll threshold configuration of the PTME IP core is now configurable via a parameter command
+  and is set to 0b010 (4 polls) instead of 0b001 (1 poll) per default.
+- EIVE system fallback and COM system fallback: Perform general subsystem handling first, then
+  event reception, and finally any new transition handling.
+- IMTQ MGM integration time lowered to 6 ms. This relaxes scheduling requirements a bit.
+- PCDU handler switcher HK set now has additional 3V3 switcher state HK.
+
+# [v1.42.0] 2023-04-01
+
+- eive-tmtc: v2.20.1
+- q7s-package: v2.3.0
+
+## Changed
+
+- SCEX filename updates. Also use T as the file ID / date separator between date and time.
+- COM TM store and dump handling: Introduce modes for all 4 TM VC/store tasks. The OFF mode can be
+  used to disable ongoing dumps or to prevent writes to the PTME VC. This allows cleaner reset
+  handling of the PTME. All 4 VC/store tasks were attached to the COM mode tree and are commanded
+  as part of the COM sequence as well to ensure consistent state with the CCSDS IP core handler.
+- Added `PTME_LOCKED` boolean lock which is used to lock the PTME so it is not used by the VC tasks
+  anymore. This lock will be controlled by the CCSDS IP core handler and is locked when the PTME
+  needs to be reset. Examples for this are datarate changes.
+- Simulate real PCDU in PCDU dummy by remembering commandes switch change and triggering appropriate
+  events. Switch feedback is still immediate.
+- GomSpace devices are polled with a doubled frequency. This speeds up power switch commanding.
+
+## Fixed
+
+- Bugfix for side lane transitions of the dual lane assemblies, which only worked when the
+  assembly was directly commanded.
+- Syrlinks Handler: Bugfix so transition command is only sent once.
+- SCEX file name bug: Create file name time stamp with `strftime` similarly to how it's done
+  for the persistent TM store.
+
+## Added
+
+- Added GPS0 and GPS1 health device which are used by the ACS board assembly when deciding whether
+  to change to the other side or to go to dual side directly. Setting the health devices to faulty
+  should also trigger a side switch or a switch to dual mode.
+
 # [v1.41.0] 2023-03-28
 
-eive-tmtc: v2.20.0
-q7s-package: v2.2.0
+- eive-tmtc: v2.20.0
+- q7s-package: v2.2.0
 
 ## Fixed
 

CMakeLists.txt

@@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 41)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_MAJOR 2)
+set(OBSW_VERSION_MINOR 0)
+set(OBSW_VERSION_REVISION 4)
 
 # set(CMAKE_VERBOSE TRUE)
 
@@ -94,6 +94,9 @@ set(OBSW_ADD_SUN_SENSORS
 set(OBSW_ADD_SUS_BOARD_ASS
     ${INIT_VAL}
     CACHE STRING "Add sun sensor board assembly")
+set(OBSW_ADD_THERMAL_TEMP_INSERTER
+    ${OBSW_Q7S_EM}
+    CACHE STRING "Add thermal sensor temperature inserter")
 set(OBSW_ADD_ACS_BOARD
     ${INIT_VAL}
     CACHE STRING "Add ACS board module")
@@ -113,7 +116,7 @@ set(OBSW_ADD_TCS_CTRL
     1
     CACHE STRING "Add TCS controllers")
 set(OBSW_ADD_HEATERS
-    ${INIT_VAL}
+    1
     CACHE STRING "Add TCS heaters")
 set(OBSW_ADD_PLOC_SUPERVISOR
     ${INIT_VAL}
@@ -220,7 +223,7 @@ set(LIB_EIVE_MISSION_PATH mission)
 set(LIB_ETL_PATH ${THIRD_PARTY_FOLDER}/etl)
 set(LIB_CATCH2_PATH ${THIRD_PARTY_FOLDER}/Catch2)
 set(LIB_LWGPS_PATH ${THIRD_PARTY_FOLDER}/lwgps)
-set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/arcsec_star_tracker)
+set(LIB_ARCSEC_PATH ${THIRD_PARTY_FOLDER}/sagittactl)
 set(LIB_JSON_PATH ${THIRD_PARTY_FOLDER}/json)
 
 set(FSFW_WARNING_SHADOW_LOCAL_GCC OFF)
@@ -486,7 +489,8 @@ endif()
 target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_FSFW_NAME}
                                                  ${LIB_OS_NAME})
 
-target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
+target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_EIVE_MISSION}
+                                            ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
 
 target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})
 

automation/Jenkinsfile

@@ -22,7 +22,7 @@ pipeline {
             steps {
                 dir(BUILDDIR_Q7S) {
                     sh 'cmake -DTGT_BSP="arm/q7s" -DCMAKE_BUILD_TYPE=Debug ..'
-                    sh 'cmake --build . -j6'
+                    sh 'cmake --build . -j8'
                 }
             }
         }
@@ -30,7 +30,7 @@ pipeline {
             steps {
                 dir(BUILDDIR_Q7S_EM) {
                     sh 'cmake -DTGT_BSP="arm/q7s" -DEIVE_Q7S_EM=ON -DCMAKE_BUILD_TYPE=Debug ..'
-                    sh 'cmake --build . -j6'
+                    sh 'cmake --build . -j8'
                 }
             }
         }
@@ -38,7 +38,7 @@ pipeline {
             steps {
                 dir(BUILDDIR_LINUX) {
                     sh 'cmake ..'
-                    sh 'cmake --build . -j6'
+                    sh 'cmake --build . -j8'
                     sh './eive-unittest'
                 }
             }

bsp_hosted/ObjectFactory.cpp

@@ -11,6 +11,7 @@
 #include "../mission/utility/DummySdCardManager.h"
 #include "OBSWConfig.h"
 #include "fsfw/platform.h"
+#include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw_tests/integration/task/TestTask.h"
 
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
@@ -29,7 +30,7 @@
 #include <dummies/AcuDummy.h>
 #include <dummies/CoreControllerDummy.h>
 
-#include "dummies/helpers.h"
+#include "dummies/helperFactory.h"
 
 #ifdef PLATFORM_UNIX
 #include <fsfw_hal/linux/serial/SerialComIF.h>
@@ -67,6 +68,12 @@ void ObjectFactory::produce(void* args) {
 
   auto* dummyGpioIF = new DummyGpioIF();
   auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  std::vector<ReturnValue_t> switcherList;
+  auto initVal = PowerSwitchIF::SWITCH_OFF;
+  for (unsigned i = 0; i < 18; i++) {
+    switcherList.emplace_back(initVal);
+  }
+  dummySwitcher->setInitialSwitcherList(switcherList);
 #ifdef PLATFORM_UNIX
   new SerialComIF(objects::UART_COM_IF);
 #if OBSW_ADD_PLOC_MPSOC == 1

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 291 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateEvents.h"
 
@@ -97,6 +97,7 @@ const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 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 *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
@@ -160,8 +161,11 @@ const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
 const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_TRYING_RESET_WITH_INIT_STRING = "PDEC_TRYING_RESET_WITH_INIT";
+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 *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";
@@ -209,11 +213,11 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING = "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
-const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING =
-    "SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903";
+const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903";
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
@@ -266,14 +270,17 @@ const char *VERSION_INFO_STRING = "VERSION_INFO";
 const char *CURRENT_IMAGE_INFO_STRING = "CURRENT_IMAGE_INFO";
 const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
-const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
+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 *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";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+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 *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";
@@ -477,8 +484,10 @@ const char *translateEvents(Event event) {
     case (11204):
       return MEKF_RECOVERY_STRING;
     case (11205):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
+    case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
@@ -603,9 +612,15 @@ const char *translateEvents(Event event) {
     case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
     case (12410):
-      return PDEC_RESET_FAILED_STRING;
+      return PDEC_TRYING_RESET_WITH_INIT_STRING;
     case (12411):
+      return PDEC_TRYING_RESET_NO_INIT_STRING;
+    case (12412):
+      return PDEC_RESET_FAILED_STRING;
+    case (12413):
       return OPEN_IRQ_FILE_FAILED_STRING;
+    case (12414):
+      return PDEC_INIT_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -700,6 +715,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):
@@ -813,21 +830,27 @@ const char *translateEvents(Event event) {
     case (14008):
       return INDIVIDUAL_BOOT_COUNTS_STRING;
     case (14010):
-      return I2C_UNAVAILABLE_REBOOT_STRING;
+      return TRYING_I2C_RECOVERY_STRING;
+    case (14011):
+      return I2C_REBOOT_STRING;
+    case (14012):
+      return PDEC_REBOOT_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
+    case (14108):
+      return MGT_OVERHEATING_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 169 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 171 translations.
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateObjects.h"
 
@@ -38,6 +38,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -242,6 +244,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

bsp_hosted/scheduling.cpp

@@ -151,11 +151,14 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
   }
-
   result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
   }
+  result = thermalTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 
   FixedTimeslotTaskIF* pstTask = factory->createFixedTimeslotTask(
       "DUMMY_PST", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
@@ -193,7 +196,8 @@ void scheduling::initTasks() {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 
   PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
-      "DUMMY_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+      "DUMMY_TASK", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  dummyTask->addComponent(objects::THERMAL_TEMP_INSERTER);
   scheduling::scheduleTmpTempSensors(dummyTask);
   scheduling::scheduleRtdSensors(dummyTask);
   dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);

bsp_q7s/OBSWConfig.h.in

@@ -43,6 +43,9 @@
 #define OBSW_ADD_PL_PCDU                            @OBSW_ADD_PL_PCDU@
 #define OBSW_ADD_SYRLINKS                           @OBSW_ADD_SYRLINKS@
 #define OBSW_ADD_CCSDS_IP_CORES                     @OBSW_ADD_CCSDS_IP_CORES@
+// Only relevant for EM for TCS tests.
+#define OBSW_ADD_THERMAL_TEMP_INSERTER              @OBSW_ADD_THERMAL_TEMP_INSERTER@
+
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             @OBSW_TM_TO_PTME@
 // Set to 1 if telecommands are received via the PDEC IP Core

bsp_q7s/callbacks/rwSpiCallback.cpp

@@ -252,7 +252,7 @@ ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpi
   fd = open(devname.c_str(), flags);
   if (fd < 0) {
     sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
-    return SpiComIF::OPENING_FILE_FAILED;
+    return spi::OPENING_FILE_FAILED;
   }
 
   // Pull SPI CS low. For now, no support for active high given

bsp_q7s/core/CoreController.cpp

@@ -31,8 +31,7 @@
 xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
-CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t &i2cErrors,
-                               bool enableHkSet)
+CoreController::CoreController(object_id_t objectId, bool enableHkSet)
     : ExtendedControllerBase(objectId, 5),
       enableHkSet(enableHkSet),
       cmdExecutor(4096),
@@ -41,7 +40,7 @@ CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t
       opDivider5(5),
       opDivider10(10),
       hkSet(this),
-      i2cErrors(i2cErrors) {
+      paramHelper(this) {
   cmdExecutor.setRingBuffer(&cmdReplyBuf, &cmdRepliesSizes);
   try {
     sdcMan = SdCardManager::instance();
@@ -55,7 +54,6 @@ CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t
     // Set up state of SD card manager and own initial state.
     // Stopwatch watch;
     sdcMan->updateSdCardStateFile();
-    sdcMan->updateSdStatePair();
     SdCardManager::SdStatePair sdStates;
     sdcMan->getSdCardsStatus(sdStates);
     auto sdCard = sdcMan->getPreferredSdCard();
@@ -90,6 +88,10 @@ CoreController::CoreController(object_id_t objectId, const std::atomic_uint16_t
 CoreController::~CoreController() {}
 
 ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
+  ReturnValue_t result = paramHelper.handleParameterMessage(message);
+  if (result == returnvalue::OK) {
+    return result;
+  }
   return ExtendedControllerBase::handleCommandMessage(message);
 }
 
@@ -110,17 +112,12 @@ void CoreController::performControlOperation() {
   sdStateMachine();
   performMountedSdCardOperations();
   readHkData();
-  if (i2cErrors >= 5) {
-    bool protOpPerformed = false;
-    triggerEvent(I2C_UNAVAILABLE_REBOOT);
-    gracefulShutdownTasks(CURRENT_CHIP, CURRENT_COPY, protOpPerformed);
-    std::system("xsc_boot_copy -r");
-  }
+
   if (shellCmdIsExecuting) {
     bool replyReceived = false;
     // TODO: We could read the data in the ring buffer and send it as an action data reply.
     if (cmdExecutor.check(replyReceived) == CommandExecutor::EXECUTION_FINISHED) {
-      actionHelper.finish(true, successRecipient, EXECUTE_SHELL_CMD);
+      actionHelper.finish(true, successRecipient, core::EXECUTE_SHELL_CMD_BLOCKING);
       shellCmdIsExecuting = false;
       cmdReplyBuf.clear();
       while (not cmdRepliesSizes.empty()) {
@@ -138,7 +135,7 @@ ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &local
   localDataPoolMap.emplace(core::TEMPERATURE, &tempPoolEntry);
   localDataPoolMap.emplace(core::PS_VOLTAGE, &psVoltageEntry);
   localDataPoolMap.emplace(core::PL_VOLTAGE, &plVoltageEntry);
-  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), enableHkSet, 12.0});
+  poolManager.subscribeForRegularPeriodicPacket({hkSet.getSid(), enableHkSet, 60.0});
   return returnvalue::OK;
 }
 
@@ -161,9 +158,14 @@ ReturnValue_t CoreController::initialize() {
                  << std::endl;
   }
 
+  result = paramHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
   sdStateMachine();
 
-  triggerEvent(REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
+  triggerEvent(core::REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
   EventManagerIF *eventManager =
       ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (eventManager == nullptr or eventQueue == nullptr) {
@@ -202,6 +204,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
 
 ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                             const uint8_t *data, size_t size) {
+  using namespace core;
   switch (actionId) {
     case (ANNOUNCE_VERSION): {
       uint32_t p1 = (common::OBSW_VERSION_MAJOR << 24) | (common::OBSW_VERSION_MINOR << 16) |
@@ -230,6 +233,84 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
     case (LIST_DIRECTORY_INTO_FILE): {
       return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
     }
+    case (LIST_DIRECTORY_DUMP_DIRECTLY): {
+      return actionListDirectoryDumpDirectly(actionId, commandedBy, data, size);
+    }
+    case (CP_HELPER): {
+      CpHelperParser parser(data, size);
+      ReturnValue_t result = parser.parse();
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      std::ostringstream oss("cp ", std::ostringstream::ate);
+      if (parser.isRecursiveOptSet()) {
+        oss << "-r ";
+      }
+      auto &sourceTgt = parser.destTgtPair();
+      oss << sourceTgt.sourceName << " " << sourceTgt.targetName;
+      sif::info << "CoreController: Performing copy command: " << oss.str() << std::endl;
+      int ret = std::system(oss.str().c_str());
+      if (ret != 0) {
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
+    case (MV_HELPER): {
+      MvHelperParser parser(data, size);
+      ReturnValue_t result = parser.parse();
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      std::ostringstream oss("mv ", std::ostringstream::ate);
+      auto &sourceTgt = parser.destTgtPair();
+      oss << sourceTgt.sourceName << " " << sourceTgt.targetName;
+      sif::info << "CoreController: Performing move command: " << oss.str() << std::endl;
+      int ret = std::system(oss.str().c_str());
+      if (ret != 0) {
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
+    case (RM_HELPER): {
+      RmHelperParser parser(data, size);
+      ReturnValue_t result = parser.parse();
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      std::ostringstream oss("rm ", std::ostringstream::ate);
+      if (parser.isRecursiveOptSet() or parser.isForceOptSet()) {
+        oss << "-";
+      }
+      if (parser.isRecursiveOptSet()) {
+        oss << "r";
+      }
+      if (parser.isForceOptSet()) {
+        oss << "f";
+      }
+      size_t removeTargetSize = 0;
+      const char *removeTgt = parser.getRemoveTarget(removeTargetSize);
+      oss << " " << removeTgt;
+      sif::info << "CoreController: Performing remove command: " << oss.str() << std::endl;
+      int ret = std::system(oss.str().c_str());
+      if (ret != 0) {
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
+    case (MKDIR_HELPER): {
+      if (size < 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      std::string createdDir = std::string(reinterpret_cast<const char *>(data), size);
+      std::ostringstream oss("mkdir ", std::ostringstream::ate);
+      oss << createdDir;
+      sif::info << "CoreController: Performing directory creation: " << oss.str() << std::endl;
+      int ret = std::system(oss.str().c_str());
+      if (ret != 0) {
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
     case (SWITCH_REBOOT_FILE_HANDLING): {
       if (size < 1) {
         return HasActionsIF::INVALID_PARAMETERS;
@@ -300,6 +381,41 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       // Completion will be reported by SD card state machine
       return returnvalue::OK;
     }
+    case (SYSTEMCTL_CMD_EXECUTOR): {
+      // Expect one byte systemctl command type and a unit name with at least one byte as minimum.
+      if (size < 2) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      if (data[0] >= core::SystemctlCmd::NUM_CMDS) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      core::SystemctlCmd cmdType = static_cast<core::SystemctlCmd>(data[0]);
+      std::string unitName = std::string(reinterpret_cast<const char *>(data + 1), size - 1);
+      std::ostringstream oss("systemctl ", std::ostringstream::ate);
+      switch (cmdType) {
+        case (core::SystemctlCmd::START): {
+          oss << "start ";
+          break;
+        }
+        case (core::SystemctlCmd::STOP): {
+          oss << "stop ";
+          break;
+        }
+        case (core::SystemctlCmd::RESTART): {
+          oss << "restart ";
+          break;
+        }
+        default: {
+          return HasActionsIF::INVALID_PARAMETERS;
+        }
+      }
+      oss << unitName;
+      int result = std::system(oss.str().c_str());
+      if (result != 0) {
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
     case (SWITCH_IMG_LOCK): {
       if (size != 3) {
         return HasActionsIF::INVALID_PARAMETERS;
@@ -330,13 +446,22 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       // Warning: This function will never return, because it reboots the system
       return actionReboot(data, size);
     }
-    case (EXECUTE_SHELL_CMD): {
-      std::string cmd = std::string(cmd, size);
+    case (EXECUTE_SHELL_CMD_BLOCKING): {
+      std::string cmdToExecute = std::string(reinterpret_cast<const char *>(data), size);
+      int result = std::system(cmdToExecute.c_str());
+      if (result != 0) {
+        // TODO: Data reply with returnalue maybe?
+        return returnvalue::FAILED;
+      }
+      return EXECUTION_FINISHED;
+    }
+    case (EXECUTE_SHELL_CMD_NON_BLOCKING): {
+      std::string cmdToExecute = std::string(reinterpret_cast<const char *>(data), size);
       if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING or
           shellCmdIsExecuting) {
         return HasActionsIF::IS_BUSY;
       }
-      cmdExecutor.load(cmd, false, false);
+      cmdExecutor.load(cmdToExecute, false, false);
       ReturnValue_t result = cmdExecutor.execute();
       if (result != returnvalue::OK) {
         return result;
@@ -373,7 +498,7 @@ ReturnValue_t CoreController::initSdCardBlocking() {
   }
 
   if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
-    updateSdInfoOther();
+    updateInternalSdInfo();
     sif::info << "Cold redundant SD card configuration, preferred SD card: "
               << static_cast<int>(sdInfo.active) << std::endl;
     result = sdColdRedundantBlockingInit();
@@ -409,23 +534,23 @@ ReturnValue_t CoreController::sdStateMachine() {
     } else {
       // Still update SD state file
       if (sdInfo.cfgMode == SdCfgMode::PASSIVE) {
-        sdFsmState = SdStates::UPDATE_INFO;
+        sdFsmState = SdStates::UPDATE_SD_INFO_END;
       } else {
         sdInfo.cycleCount = 0;
-        sdInfo.commandExecuted = false;
-        sdFsmState = SdStates::GET_INFO;
+        sdInfo.commandPending = false;
+        sdFsmState = SdStates::UPDATE_SD_INFO_START;
       }
     }
   }
 
-  // This lambda checks the non-blocking operation and assigns the new state on success.
-  // It returns true for an operation success and false otherwise
-  auto nonBlockingOpChecking = [&](SdStates newStateOnSuccess, uint16_t maxCycleCount,
-                                   std::string opPrintout) {
+  // This lambda checks the non-blocking operation of the SD card manager and assigns the new
+  // state on success. It returns true for an operation success and false otherwise
+  auto nonBlockingSdcOpChecking = [&](SdStates newStateOnSuccess, uint16_t maxCycleCount,
+                                      std::string opPrintout) {
     SdCardManager::OpStatus status = sdcMan->checkCurrentOp(operation);
     if (status == SdCardManager::OpStatus::SUCCESS) {
       sdFsmState = newStateOnSuccess;
-      sdInfo.commandExecuted = false;
+      sdInfo.commandPending = false;
       sdInfo.cycleCount = 0;
       return true;
     } else if (sdInfo.cycleCount > 4) {
@@ -436,26 +561,29 @@ ReturnValue_t CoreController::sdStateMachine() {
     return false;
   };
 
-  if (sdFsmState == SdStates::GET_INFO) {
-    if (not sdInfo.commandExecuted) {
+  if (sdFsmState == SdStates::UPDATE_SD_INFO_START) {
+    if (not sdInfo.commandPending) {
       // Create updated status file
       result = sdcMan->updateSdCardStateFile();
       if (result != returnvalue::OK) {
         sif::warning << "CoreController::sdStateMachine: Updating SD card state file failed"
                      << std::endl;
       }
-      sdFsmState = SdStates::SET_STATE_SELF;
-      sdInfo.commandExecuted = false;
-      sdInfo.cycleCount = 0;
-    } else {
-      nonBlockingOpChecking(SdStates::SET_STATE_SELF, 4, "Updating SDC file");
-    }
-  }
-
-  if (sdFsmState == SdStates::SET_STATE_SELF) {
-    if (not sdInfo.commandExecuted) {
       result = sdcMan->getSdCardsStatus(sdInfo.currentState);
-      updateSdInfoOther();
+      updateInternalSdInfo();
+      auto currentlyActiveSdc = sdcMan->getActiveSdCard();
+      // Used/active SD card switches, so mark SD card unusable so other tasks have some time
+      // registering the unavailable SD card.
+      if (not currentlyActiveSdc.has_value() or
+          ((currentlyActiveSdc.value() == sd::SdCard::SLOT_0) and
+           (sdInfo.active == sd::SdCard::SLOT_1)) or
+          ((currentlyActiveSdc.value() == sd::SdCard::SLOT_1) and
+           (sdInfo.active == sd::SdCard::SLOT_0))) {
+        sdInfo.lockSdCardUsage = true;
+      }
+      if (sdInfo.lockSdCardUsage) {
+        sdcMan->markUnusable();
+      }
       if (sdInfo.active != sd::SdCard::SLOT_0 and sdInfo.active != sd::SdCard::SLOT_1) {
         sif::warning << "Preferred SD card invalid. Setting to card 0.." << std::endl;
         sdInfo.active = sd::SdCard::SLOT_0;
@@ -467,7 +595,11 @@ ReturnValue_t CoreController::sdStateMachine() {
         sif::info << "Cold redundant SD card configuration, target SD card: "
                   << static_cast<int>(sdInfo.active) << std::endl;
       }
+      SdStates tgtState = SdStates::IDLE;
+      bool skipCycles = sdInfo.lockSdCardUsage;
+      // Need to do different things depending on state of SD card which will be active.
       if (sdInfo.activeState == sd::SdState::MOUNTED) {
+        // Already mounted, so we can perform handling of the other side.
 #if OBSW_VERBOSE_LEVEL >= 1
         std::string mountString;
         if (sdInfo.active == sd::SdCard::SLOT_0) {
@@ -480,27 +612,57 @@ ReturnValue_t CoreController::sdStateMachine() {
 #endif
         sdcMan->setActiveSdCard(sdInfo.active);
         currMntPrefix = sdcMan->getCurrentMountPrefix();
-        sdFsmState = SdStates::DETERMINE_OTHER;
+        tgtState = SdStates::DETERMINE_OTHER;
       } else if (sdInfo.activeState == sd::SdState::OFF) {
+        // It's okay to do the delay after swichting active SD on, no one can use it anyway..
         sdCardSetup(sdInfo.active, sd::SdState::ON, sdInfo.activeChar, false);
-        sdInfo.commandExecuted = true;
+        sdInfo.commandPending = true;
+        // Do not skip cycles here, would mess up the state machine. We skip the cycles after
+        // the SD card was switched on.
+        skipCycles = false;
+        // Remain on the current state.
+        tgtState = sdFsmState;
       } else if (sdInfo.activeState == sd::SdState::ON) {
-        sdFsmState = SdStates::MOUNT_SELF;
+        // We can do the delay before mounting where applicable.
+        tgtState = SdStates::MOUNT_SELF;
+      }
+      if (skipCycles) {
+        sdFsmState = SdStates::SKIP_TWO_CYCLES_IF_SD_LOCKED;
+        fsmStateAfterDelay = tgtState;
+        sdInfo.skippedCyclesCount = 0;
+      } else {
+        sdFsmState = tgtState;
       }
     } else {
-      if (nonBlockingOpChecking(SdStates::MOUNT_SELF, 10, "Setting SDC state")) {
+      if (nonBlockingSdcOpChecking(SdStates::MOUNT_SELF, 10, "Setting SDC state")) {
         sdInfo.activeState = sd::SdState::ON;
         currentStateSetter(sdInfo.active, sd::SdState::ON);
+        // Skip the two cycles now.
+        if (sdInfo.lockSdCardUsage) {
+          sdFsmState = SdStates::SKIP_TWO_CYCLES_IF_SD_LOCKED;
+          fsmStateAfterDelay = SdStates::MOUNT_SELF;
+          sdInfo.skippedCyclesCount = 0;
+        }
       }
     }
   }
 
+  if (sdFsmState == SdStates::SKIP_TWO_CYCLES_IF_SD_LOCKED) {
+    sdInfo.skippedCyclesCount++;
+    // Count to three because this branch will run in the same FSM cycle.
+    if (sdInfo.skippedCyclesCount == 3) {
+      sdFsmState = fsmStateAfterDelay;
+      fsmStateAfterDelay = SdStates::IDLE;
+      sdInfo.skippedCyclesCount = 0;
+    }
+  }
+
   if (sdFsmState == SdStates::MOUNT_SELF) {
-    if (not sdInfo.commandExecuted) {
+    if (not sdInfo.commandPending) {
       result = sdCardSetup(sdInfo.active, sd::SdState::MOUNTED, sdInfo.activeChar);
-      sdInfo.commandExecuted = true;
+      sdInfo.commandPending = true;
     } else {
-      if (nonBlockingOpChecking(SdStates::DETERMINE_OTHER, 5, "Mounting SD card")) {
+      if (nonBlockingSdcOpChecking(SdStates::DETERMINE_OTHER, 5, "Mounting SD card")) {
         sdcMan->setActiveSdCard(sdInfo.active);
         currMntPrefix = sdcMan->getCurrentMountPrefix();
         sdInfo.activeState = sd::SdState::MOUNTED;
@@ -537,23 +699,33 @@ ReturnValue_t CoreController::sdStateMachine() {
   if (sdFsmState == SdStates::SET_STATE_OTHER) {
     // Set state of other SD card to ON or OFF, depending on redundancy mode
     if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
-      if (not sdInfo.commandExecuted) {
+      if (not sdInfo.commandPending) {
         result = sdCardSetup(sdInfo.other, sd::SdState::OFF, sdInfo.otherChar, false);
-        sdInfo.commandExecuted = true;
+        sdInfo.commandPending = true;
       } else {
-        if (nonBlockingOpChecking(SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE, 10,
-                                  "Switching off other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE, 10,
+                                     "Switching off other SD card")) {
+          sdInfo.otherState = sd::SdState::OFF;
+          currentStateSetter(sdInfo.other, sd::SdState::OFF);
+        } else {
+          // Continue.. avoid being stuck here..
+          sdFsmState = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
           sdInfo.otherState = sd::SdState::OFF;
           currentStateSetter(sdInfo.other, sd::SdState::OFF);
         }
       }
     } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
-      if (not sdInfo.commandExecuted) {
+      if (not sdInfo.commandPending) {
         result = sdCardSetup(sdInfo.other, sd::SdState::ON, sdInfo.otherChar, false);
-        sdInfo.commandExecuted = true;
+        sdInfo.commandPending = true;
       } else {
-        if (nonBlockingOpChecking(SdStates::MOUNT_UNMOUNT_OTHER, 10,
-                                  "Switching on other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::MOUNT_UNMOUNT_OTHER, 10,
+                                     "Switching on other SD card")) {
+          sdInfo.otherState = sd::SdState::ON;
+          currentStateSetter(sdInfo.other, sd::SdState::ON);
+        } else {
+          // Contnue.. avoid being stuck here.
+          sdFsmState = SdStates::MOUNT_UNMOUNT_OTHER;
           sdInfo.otherState = sd::SdState::ON;
           currentStateSetter(sdInfo.other, sd::SdState::ON);
         }
@@ -564,21 +736,25 @@ ReturnValue_t CoreController::sdStateMachine() {
   if (sdFsmState == SdStates::MOUNT_UNMOUNT_OTHER) {
     // Mount or unmount other SD card, depending on redundancy mode
     if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
-      if (not sdInfo.commandExecuted) {
+      if (not sdInfo.commandPending) {
         result = sdCardSetup(sdInfo.other, sd::SdState::ON, sdInfo.otherChar);
-        sdInfo.commandExecuted = true;
+        sdInfo.commandPending = true;
       } else {
-        if (nonBlockingOpChecking(SdStates::SET_STATE_OTHER, 10, "Unmounting other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::SET_STATE_OTHER, 10, "Unmounting other SD card")) {
           sdInfo.otherState = sd::SdState::ON;
           currentStateSetter(sdInfo.other, sd::SdState::ON);
+        } else {
+          sdInfo.otherState = sd::SdState::ON;
+          currentStateSetter(sdInfo.other, sd::SdState::ON);
+          sdFsmState = SdStates::SET_STATE_OTHER;
         }
       }
     } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
-      if (not sdInfo.commandExecuted) {
+      if (not sdInfo.commandPending) {
         result = sdCardSetup(sdInfo.other, sd::SdState::MOUNTED, sdInfo.otherChar);
-        sdInfo.commandExecuted = true;
+        sdInfo.commandPending = true;
       } else {
-        if (nonBlockingOpChecking(SdStates::UPDATE_INFO, 4, "Mounting other SD card")) {
+        if (nonBlockingSdcOpChecking(SdStates::UPDATE_SD_INFO_END, 4, "Mounting other SD card")) {
           sdInfo.otherState = sd::SdState::MOUNTED;
           currentStateSetter(sdInfo.other, sd::SdState::MOUNTED);
         }
@@ -587,14 +763,17 @@ ReturnValue_t CoreController::sdStateMachine() {
   }
 
   if (sdFsmState == SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE) {
-    sdFsmState = SdStates::UPDATE_INFO;
-  } else if (sdFsmState == SdStates::UPDATE_INFO) {
+    sdFsmState = SdStates::UPDATE_SD_INFO_END;
+  } else if (sdFsmState == SdStates::UPDATE_SD_INFO_END) {
     // Update status file
     result = sdcMan->updateSdCardStateFile();
     if (result != returnvalue::OK) {
-      sif::warning << "CoreController::initialize: Updating SD card state file failed" << std::endl;
+      sif::warning << "CoreController: Updating SD card state file failed" << std::endl;
     }
-    sdInfo.commandExecuted = false;
+    updateInternalSdInfo();
+    // Mark usable again in any case.
+    sdcMan->markUsable();
+    sdInfo.commandPending = false;
     sdFsmState = SdStates::IDLE;
     sdInfo.cycleCount = 0;
     sdcMan->setBlocking(false);
@@ -604,8 +783,16 @@ ReturnValue_t CoreController::sdStateMachine() {
       actionHelper.finish(true, sdCommandingInfo.commander, sdCommandingInfo.actionId,
                           returnvalue::OK);
     }
+    const char *modeStr = "UNKNOWN";
+    if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
+      modeStr = "COLD REDUNDANT";
+    } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
+      modeStr = "HOT REDUNDANT";
+    }
+    sif::info << "SD card update into " << modeStr
+              << " mode finished. Active SD: " << sdInfo.activeChar << std::endl;
     if (not sdInfo.initFinished) {
-      updateSdInfoOther();
+      updateInternalSdInfo();
       sdInfo.initFinished = true;
       sif::info << "SD card initialization finished" << std::endl;
     }
@@ -802,59 +989,144 @@ ReturnValue_t CoreController::initVersionFile() {
   return returnvalue::OK;
 }
 
-ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
-                                                          MessageQueueId_t commandedBy,
-                                                          const uint8_t *data, size_t size) {
-  // TODO: Packet definition for clean deserialization
-  // 2 bytes for a and R flag, at least 5 bytes for minimum valid path /tmp with
-  // null termination, at least 7 bytes for minimum target file name /tmp/a with
-  // null termination.
-  if (size < 14) {
-    return HasActionsIF::INVALID_PARAMETERS;
+ReturnValue_t CoreController::actionListDirectoryDumpDirectly(ActionId_t actionId,
+                                                              MessageQueueId_t commandedBy,
+                                                              const uint8_t *data, size_t size) {
+  core::ListDirectoryCmdBase parser(data, size);
+  ReturnValue_t result = parser.parse();
+  if (result != returnvalue::OK) {
+    return result;
   }
-  // We could also make -l optional, but I can't think of a reason why to not use -l..
 
-  // This flag specifies to run ls with -a
-  bool aFlag = data[0];
-  data += 1;
-  // This flag specifies to run ls with -R
-  bool RFlag = data[1];
-  data += 1;
-
-  size_t remainingSize = size - 2;
-  // One larger for null termination, which prevents undefined behaviour if the sent
-  // strings are not 0 terminated properly
-  std::vector<uint8_t> repoAndTargetFileBuffer(remainingSize + 1, 0);
-  std::memcpy(repoAndTargetFileBuffer.data(), data, remainingSize);
-  const char *currentCharPtr = reinterpret_cast<const char *>(repoAndTargetFileBuffer.data());
-  // Full target file name
-  std::string repoName(currentCharPtr);
-  size_t repoLength = repoName.length();
-  // The other string needs to be at least one letter plus NULL termination to be valid at all
-  // The first string also needs to be NULL terminated, but the termination is not included
-  // in the string length, so this is subtracted from the remaining size as well
-  if (repoLength > remainingSize - 3) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
-  // The file length will not include the NULL termination, so we skip it
-  currentCharPtr += repoLength + 1;
-  std::string targetFileName(currentCharPtr);
-  std::ostringstream oss;
-  oss << "ls -l";
-  if (aFlag) {
+  std::ostringstream oss("ls -l", std::ostringstream::ate);
+  if (parser.aFlagSet()) {
     oss << "a";
   }
-  if (RFlag) {
+  if (parser.rFlagSet()) {
     oss << "R";
   }
 
-  oss << " " << repoName << " > " << targetFileName;
-  int result = std::system(oss.str().c_str());
-  if (result != 0) {
-    utility::handleSystemError(result, "CoreController::actionListDirectoryIntoFile");
-    actionHelper.finish(false, commandedBy, actionId);
+  size_t repoNameLen = 0;
+  const char *repoName = parser.getRepoName(repoNameLen);
+
+  oss << " " << repoName << " > " << LIST_DIR_DUMP_WORK_FILE;
+  sif::info << "Executing " << oss.str() << " for direct dump";
+  if (parser.compressionOptionSet()) {
+    sif::info << " with compression";
   }
-  return returnvalue::OK;
+  sif::info << std::endl;
+  int ret = std::system(oss.str().c_str());
+  if (ret != 0) {
+    utility::handleSystemError(result, "CoreController::actionListDirectoryDumpDirectly");
+    return returnvalue::FAILED;
+  }
+  if (parser.compressionOptionSet()) {
+    std::string compressedName = LIST_DIR_DUMP_WORK_FILE + std::string(".gz");
+    oss.str("");
+    oss << "gzip " << LIST_DIR_DUMP_WORK_FILE;
+    ret = std::system(oss.str().c_str());
+    if (ret != 0) {
+      utility::handleSystemError(result, "CoreController::actionListDirectoryDumpDirectly");
+      return returnvalue::FAILED;
+    }
+    oss.str("");
+    // Overwrite the work file with the compressed archive.
+    oss << "mv " << compressedName << " " << LIST_DIR_DUMP_WORK_FILE;
+    ret = std::system(oss.str().c_str());
+    if (ret != 0) {
+      utility::handleSystemError(result, "CoreController::actionListDirectoryDumpDirectly");
+      return returnvalue::FAILED;
+    }
+  }
+  std::array<uint8_t, 1024> dirListingBuf{};
+  dirListingBuf[8] = parser.compressionOptionSet();
+  // First four bytes reserved for segment index. One byte for compression option information
+  std::strcpy(reinterpret_cast<char *>(dirListingBuf.data() + 2 * sizeof(uint32_t) + 1), repoName);
+  std::ifstream ifile(LIST_DIR_DUMP_WORK_FILE, std::ios::binary);
+  if (ifile.bad()) {
+    return returnvalue::FAILED;
+  }
+  std::error_code e;
+  size_t totalFileSize = std::filesystem::file_size(LIST_DIR_DUMP_WORK_FILE, e);
+  uint32_t segmentIdx = 0;
+  size_t dumpedBytes = 0;
+  size_t nextDumpLen = 0;
+  size_t dummy = 0;
+  size_t maxDumpLen = dirListingBuf.size() - 2 * sizeof(uint32_t) - 1 - repoNameLen - 1;
+  size_t listingDataOffset = 2 * sizeof(uint32_t) + 1 + repoNameLen + 1;
+  uint32_t chunks = totalFileSize / maxDumpLen;
+  if (totalFileSize % maxDumpLen != 0) {
+    chunks++;
+  }
+  SerializeAdapter::serialize(&chunks, dirListingBuf.data() + sizeof(uint32_t), &dummy,
+                              dirListingBuf.size() - sizeof(uint32_t),
+                              SerializeIF::Endianness::NETWORK);
+  while (dumpedBytes < totalFileSize) {
+    ifile.seekg(dumpedBytes, std::ios::beg);
+    nextDumpLen = maxDumpLen;
+    if (totalFileSize - dumpedBytes < maxDumpLen) {
+      nextDumpLen = totalFileSize - dumpedBytes;
+    }
+    SerializeAdapter::serialize(&segmentIdx, dirListingBuf.data(), &dummy, dirListingBuf.size(),
+                                SerializeIF::Endianness::NETWORK);
+    ifile.read(reinterpret_cast<char *>(dirListingBuf.data() + listingDataOffset), nextDumpLen);
+    result = actionHelper.reportData(commandedBy, actionId, dirListingBuf.data(),
+                                     listingDataOffset + nextDumpLen);
+    if (result != returnvalue::OK) {
+      // Remove work file when we are done
+      std::filesystem::remove(LIST_DIR_DUMP_WORK_FILE, e);
+      return result;
+    }
+    segmentIdx++;
+    dumpedBytes += nextDumpLen;
+  }
+  // Remove work file when we are done
+  std::filesystem::remove(LIST_DIR_DUMP_WORK_FILE, e);
+  return EXECUTION_FINISHED;
+}
+
+ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
+                                                          MessageQueueId_t commandedBy,
+                                                          const uint8_t *data, size_t size) {
+  core::ListDirectoryIntoFile parser(data, size);
+  ReturnValue_t result = parser.parse();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  std::ostringstream oss("ls -l", std::ostringstream::ate);
+  if (parser.aFlagSet()) {
+    oss << "a";
+  }
+  if (parser.rFlagSet()) {
+    oss << "R";
+  }
+
+  size_t repoNameLen = 0;
+  const char *repoName = parser.getRepoName(repoNameLen);
+  size_t targetFileNameLen = 0;
+  const char *targetFileName = parser.getTargetName(targetFileNameLen);
+  oss << " " << repoName << " > " << targetFileName;
+  sif::info << "Executing list directory request, command: " << oss.str() << std::endl;
+  int ret = std::system(oss.str().c_str());
+  if (ret != 0) {
+    utility::handleSystemError(result, "CoreController::actionListDirectoryIntoFile");
+    return returnvalue::FAILED;
+  }
+
+  // Compression will add a .gz ending. I don't have any issue with this, it makes it explicit
+  // that this is a compressed file.
+  if (parser.compressionOptionSet()) {
+    oss.str("");
+    oss << "gzip " << targetFileName;
+    sif::info << "Compressing directory listing: " << oss.str() << std::endl;
+    ret = std::system(oss.str().c_str());
+    if (ret != 0) {
+      utility::handleSystemError(result, "CoreController::actionListDirectoryIntoFile");
+      return returnvalue::FAILED;
+    }
+  }
+  return EXECUTION_FINISHED;
 }
 
 ReturnValue_t CoreController::initBootCopyFile() {
@@ -982,7 +1254,7 @@ ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy co
   return result;
 }
 
-void CoreController::updateSdInfoOther() {
+void CoreController::updateInternalSdInfo() {
   if (sdInfo.active == sd::SdCard::SLOT_0) {
     sdInfo.activeChar = "0";
     sdInfo.otherChar = "1";
@@ -1242,7 +1514,7 @@ void CoreController::performMountedSdCardOperations() {
   auto mountedSdCardOp = [&](sd::SdCard sdCard, std::string mntPoint) {
     if (not performOneShotSdCardOpsSwitch) {
       std::ostringstream path;
-      path << mntPoint << "/" << CONF_FOLDER;
+      path << mntPoint << "/" << core::CONF_FOLDER;
       std::error_code e;
       if (not std::filesystem::exists(path.str()), e) {
         bool created = std::filesystem::create_directory(path.str(), e);
@@ -1324,7 +1596,7 @@ ReturnValue_t CoreController::performSdCardCheck() {
     someSdCardActive = true;
   }
   if (not someSdCardActive and remountAttemptFlag) {
-    triggerEvent(NO_SD_CARD_ACTIVE);
+    triggerEvent(core::NO_SD_CARD_ACTIVE);
     initSdCardBlocking();
     remountAttemptFlag = false;
   }
@@ -1378,7 +1650,7 @@ void CoreController::performRebootFileHandling(bool recreateFile) {
   if (rebootFile.bootFlag) {
     // Trigger event to inform ground that a reboot was triggered
     uint32_t p1 = rebootFile.lastChip << 16 | rebootFile.lastCopy;
-    triggerEvent(REBOOT_MECHANISM_TRIGGERED, p1, 0);
+    triggerEvent(core::REBOOT_MECHANISM_TRIGGERED, p1, 0);
     // Clear the boot flag
     rebootFile.bootFlag = false;
   }
@@ -1928,11 +2200,20 @@ ReturnValue_t CoreController::executeSwUpdate(SwUpdateSources sourceDir, const u
   } else if (sourceDir == SwUpdateSources::TMP_DIR) {
     prefixPath = path("/tmp");
   }
-  path archivePath = prefixPath / path(config::OBSW_UPDATE_ARCHIVE_FILE_NAME);
+  path archivePath;
+  // It is optionally possible to supply the source file path
+  if (size > 2) {
+    archivePath = prefixPath / std::string(reinterpret_cast<const char *>(data + 2), size - 2);
+  } else {
+    archivePath = prefixPath / path(config::OBSW_UPDATE_ARCHIVE_FILE_NAME);
+  }
+  sif::info << "Updating with archive path " << archivePath << std::endl;
   std::error_code e;
   if (not exists(archivePath, e)) {
     return HasFileSystemIF::FILE_DOES_NOT_EXIST;
   }
+  // TODO: Decompressing without limiting memory usage with xz is actually a bit risky..
+  // But has not been an issue so far.
   ostringstream cmd("tar -xJf", ios::app);
   cmd << " " << archivePath << " -C " << prefixPath;
   int result = system(cmd.str().c_str());
@@ -2015,6 +2296,10 @@ ReturnValue_t CoreController::executeSwUpdate(SwUpdateSources sourceDir, const u
   cmd.str("");
   cmd.clear();
 
+  // Remove the extracted files to keep directories clean.
+  std::filesystem::remove(strippedImagePath, e);
+  std::filesystem::remove(obswVersionFilePath, e);
+
   // TODO: This takes a long time and will block the core controller.. Maybe use command executor?
   //       For now dont care..
   cmd << "writeprotect " << std::to_string(data[0]) << " " << std::to_string(data[1]) << " 1";
@@ -2035,6 +2320,11 @@ bool CoreController::startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mo
   }
   sdFsmState = SdStates::START;
   sdInfo.active = targetActiveSd;
+  // If we are going from 2 SD cards to one, lock SD card usage in any case because 1 SD card is
+  // going off.
+  if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT and mode == SdCfgMode::COLD_REDUNDANT) {
+    sdInfo.lockSdCardUsage = true;
+  }
   sdInfo.cfgMode = mode;
   sdCommandingInfo.actionId = actionId;
   sdCommandingInfo.commander = commander;
@@ -2047,11 +2337,43 @@ void CoreController::announceBootCounts() {
       rebootFile.img00Cnt + rebootFile.img01Cnt + rebootFile.img10Cnt + rebootFile.img11Cnt;
   uint32_t individualBootCountsP1 = (rebootFile.img00Cnt << 16) | rebootFile.img01Cnt;
   uint32_t individualBootCountsP2 = (rebootFile.img10Cnt << 16) | rebootFile.img11Cnt;
-  triggerEvent(INDIVIDUAL_BOOT_COUNTS, individualBootCountsP1, individualBootCountsP2);
-  triggerEvent(REBOOT_COUNTER, (totalBootCount >> 32) & 0xffffffff, totalBootCount & 0xffffffff);
+  triggerEvent(core::INDIVIDUAL_BOOT_COUNTS, individualBootCountsP1, individualBootCountsP2);
+  triggerEvent(core::REBOOT_COUNTER, (totalBootCount >> 32) & 0xffffffff,
+               totalBootCount & 0xffffffff);
+}
+
+MessageQueueId_t CoreController::getCommandQueue() const {
+  return ExtendedControllerBase::getCommandQueue();
 }
 
 bool CoreController::isNumber(const std::string &s) {
   return !s.empty() && std::find_if(s.begin(), s.end(),
                                     [](unsigned char c) { return !std::isdigit(c); }) == s.end();
 }
+
+ReturnValue_t CoreController::getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                                           ParameterWrapper *parameterWrapper,
+                                           const ParameterWrapper *newValues,
+                                           uint16_t startAtIndex) {
+  if (domainId != 0) {
+    return HasParametersIF::INVALID_DOMAIN_ID;
+  }
+  if (uniqueIdentifier >= ParamId::NUM_IDS) {
+    return HasParametersIF::INVALID_IDENTIFIER_ID;
+  }
+  uint8_t newPrefSd;
+  ReturnValue_t result = newValues->getElement(&newPrefSd);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Only SD card 0 (0) and 1 (1) are allowed values.
+  if (newPrefSd > 1) {
+    return HasParametersIF::INVALID_VALUE;
+  }
+  result = sdcMan->setPreferredSdCard(static_cast<sd::SdCard>(newPrefSd));
+  if (result != returnvalue::OK) {
+    return returnvalue::FAILED;
+  }
+  parameterWrapper->set(prefSdRaw);
+  return returnvalue::OK;
+}

bsp_q7s/core/CoreController.h

@@ -4,6 +4,8 @@
 #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 <libxiphos.h>
 #include <mission/acs/archive/GPSDefinitions.h>
 #include <mission/utility/trace.h>
@@ -16,17 +18,11 @@
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
+#include "mission/sysDefs.h"
 
 class Timer;
 class SdCardManager;
 
-namespace xsc {
-
-enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
-enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
-
-}  // namespace xsc
-
 struct RebootFile {
   static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
 
@@ -48,8 +44,10 @@ struct RebootFile {
   xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
-class CoreController : public ExtendedControllerBase {
+class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
  public:
+  enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
+
   static xsc::Chip CURRENT_CHIP;
   static xsc::Copy CURRENT_COPY;
 
@@ -57,85 +55,23 @@ class CoreController : public ExtendedControllerBase {
   static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
   static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
 
-  static constexpr char CONF_FOLDER[] = "conf";
-
-  static constexpr char VERSION_FILE_NAME[] = "version.txt";
-  static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
-  static constexpr char TIME_FILE_NAME[] = "time_backup.txt";
-
   const std::string VERSION_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::VERSION_FILE_NAME);
   const std::string REBOOT_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_FILE_NAME);
   const std::string BACKUP_TIME_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_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";
   static constexpr char CHIP_1_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-nom-rootfs";
   static constexpr char CHIP_1_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-gold-rootfs";
+  static constexpr char LIST_DIR_DUMP_WORK_FILE[] = "/tmp/dir_listing.tmp";
 
   static constexpr dur_millis_t INIT_SD_CARD_CHECK_TIMEOUT = 5000;
   static constexpr dur_millis_t DEFAULT_SD_CARD_CHECK_TIMEOUT = 60000;
 
-  static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
-  static constexpr ActionId_t ANNOUNCE_VERSION = 1;
-  static constexpr ActionId_t ANNOUNCE_CURRENT_IMAGE = 2;
-  static constexpr ActionId_t ANNOUNCE_BOOT_COUNTS = 3;
-  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
-  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
-  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
-  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
-
-  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
-  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
-  static constexpr ActionId_t OBSW_UPDATE_FROM_TMP = 12;
-
-  static constexpr ActionId_t SWITCH_TO_SD_0 = 16;
-  static constexpr ActionId_t SWITCH_TO_SD_1 = 17;
-  static constexpr ActionId_t SWITCH_TO_BOTH_SD_CARDS = 18;
-
-  //! Reboot using the xsc_boot_copy command
-  static constexpr ActionId_t XSC_REBOOT_OBC = 32;
-  static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
-  //! Reboot using the reboot command
-  static constexpr ActionId_t REBOOT_OBC = 34;
-
-  static constexpr ActionId_t EXECUTE_SHELL_CMD = 40;
-
-  static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
-
-  static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
-  //! [EXPORT] : [COMMENT]  Software reboot occurred. Can also be a systemd reboot.
-  //! P1: Current Chip, P2: Current Copy
-  static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::LOW);
-  //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
-  //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
-  //! P2: Each byte is the respective reboot count for the slots
-  static constexpr Event REBOOT_MECHANISM_TRIGGERED =
-      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
-  //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
-  static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
-  //! [EXPORT] : [COMMENT] No SD card was active. Core controller will attempt to re-initialize
-  //! a SD card.
-  static constexpr Event NO_SD_CARD_ACTIVE = event::makeEvent(SUBSYSTEM_ID, 4, severity::HIGH);
-  //! [EXPORT] : [COMMENT]
-  //! P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash
-  //! P2: First four letters of Git SHA is the last byte of P1 is set.
-  static constexpr Event VERSION_INFO = event::makeEvent(SUBSYSTEM_ID, 5, severity::INFO);
-  //! [EXPORT] : [COMMENT] P1: Current Chip, P2: Current Copy
-  static constexpr Event CURRENT_IMAGE_INFO = event::makeEvent(SUBSYSTEM_ID, 6, severity::INFO);
-  //! [EXPORT] : [COMMENT] Total reboot counter, which is the sum of the boot count of all
-  //! individual images.
-  static constexpr Event REBOOT_COUNTER = event::makeEvent(SUBSYSTEM_ID, 7, severity::INFO);
-  //! [EXPORT] : [COMMENT] Get the boot count of the individual images.
-  //! P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1.
-  //! P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.
-  static constexpr Event INDIVIDUAL_BOOT_COUNTS = event::makeEvent(SUBSYSTEM_ID, 8, severity::INFO);
-  static constexpr Event I2C_UNAVAILABLE_REBOOT =
-      event::makeEvent(SUBSYSTEM_ID, 10, severity::MEDIUM);
-
-  CoreController(object_id_t objectId, const std::atomic_uint16_t& i2cErrors, bool enableHkSet);
+  CoreController(object_id_t objectId, bool enableHkSet);
   virtual ~CoreController();
 
   ReturnValue_t initialize() override;
@@ -186,8 +122,8 @@ class CoreController : public ExtendedControllerBase {
   enum class SdStates {
     NONE,
     START,
-    GET_INFO,
-    SET_STATE_SELF,
+    UPDATE_SD_INFO_START,
+    SKIP_TWO_CYCLES_IF_SD_LOCKED,
     MOUNT_SELF,
     // Determine operations for other SD card, depending on redundancy configuration
     DETERMINE_OTHER,
@@ -197,7 +133,7 @@ class CoreController : public ExtendedControllerBase {
     // Skip period because the shell command used to generate the info file sometimes is
     // missing the last performed operation if executed too early
     SKIP_CYCLE_BEFORE_INFO_UPDATE,
-    UPDATE_INFO,
+    UPDATE_SD_INFO_END,
     // SD initialization done
     IDLE
   };
@@ -209,23 +145,30 @@ class CoreController : public ExtendedControllerBase {
   SdCardManager* sdcMan = nullptr;
   MessageQueueIF* eventQueue = nullptr;
 
+  uint8_t prefSdRaw = sd::SdCard::SLOT_0;
   SdStates sdFsmState = SdStates::START;
+  SdStates fsmStateAfterDelay = SdStates::IDLE;
   enum SdCfgMode { PASSIVE, COLD_REDUNDANT, HOT_REDUNDANT };
 
   struct SdFsmParams {
     SdCfgMode cfgMode = SdCfgMode::COLD_REDUNDANT;
     sd::SdCard active = sd::SdCard::NONE;
     sd::SdCard other = sd::SdCard::NONE;
-    sd::SdState activeState = sd::SdState::OFF;
-    sd::SdState otherState = sd::SdState::OFF;
     std::string activeChar = "0";
     std::string otherChar = "1";
+    sd::SdState activeState = sd::SdState::OFF;
+    sd::SdState otherState = sd::SdState::OFF;
     std::pair<bool, bool> mountSwitch = {true, true};
-    // Used to track whether a command was executed
-    bool commandExecuted = true;
+    // This flag denotes that the SD card usage is locked. This is relevant if SD cards go off
+    // to leave appliation using the SD cards some time to detect the SD card is not usable anymore.
+    // This is relevant if the active SD card is being switched. The SD card will also be locked
+    // when going from hot-redundant mode to cold-redundant mode.
+    bool lockSdCardUsage = false;
+    bool commandPending = true;
     bool initFinished = false;
     SdCardManager::SdStatePair currentState;
     uint16_t cycleCount = 0;
+    uint16_t skippedCyclesCount = 0;
   } sdInfo;
 
   struct SdCommanding {
@@ -266,12 +209,17 @@ class CoreController : public ExtendedControllerBase {
   PoolEntry<float> plVoltageEntry = PoolEntry<float>(0.0);
 
   core::HkSet hkSet;
-  const std::atomic_uint16_t& i2cErrors;
+
+  ParameterHelper paramHelper;
 
 #if OBSW_SD_CARD_MUST_BE_ON == 1
   bool remountAttemptFlag = true;
 #endif
 
+  MessageQueueId_t getCommandQueue() const override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
+                             ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
+                             uint16_t startAtIndex) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
 
@@ -290,7 +238,7 @@ class CoreController : public ExtendedControllerBase {
   void initPrint();
 
   ReturnValue_t sdStateMachine();
-  void updateSdInfoOther();
+  void updateInternalSdInfo();
   ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                             bool printOutput = true);
   ReturnValue_t executeSwUpdate(SwUpdateSources sourceDir, const uint8_t* data, size_t size);
@@ -303,6 +251,12 @@ class CoreController : public ExtendedControllerBase {
 
   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 actionListDirectoryCommonCommandCreator(const uint8_t* data, size_t size,
+                                                        std::ostringstream& oss);
+
   ReturnValue_t actionXscReboot(const uint8_t* data, size_t size);
   ReturnValue_t actionReboot(const uint8_t* data, size_t size);
 

bsp_q7s/core/ObjectFactory.cpp

@@ -1,5 +1,6 @@
 #include "ObjectFactory.h"
 
+#include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
@@ -19,15 +20,16 @@
 #include <mission/acs/MgmRm3100CustomHandler.h>
 #include <mission/acs/str/StarTrackerHandler.h>
 #include <mission/acs/str/strHelpers.h>
+#include <mission/com/LiveTmTask.h>
+#include <mission/com/PersistentLogTmStoreTask.h>
+#include <mission/com/PersistentSingleTmStoreTask.h>
 #include <mission/power/CspCookie.h>
 #include <mission/system/acs/ImtqAssembly.h>
-#include <mission/system/fdir/StrFdir.h>
+#include <mission/system/acs/StrAssembly.h>
+#include <mission/system/acs/StrFdir.h>
+#include <mission/system/com/SyrlinksAssembly.h>
 #include <mission/system/objects/CamSwitcher.h>
-#include <mission/system/objects/StrAssembly.h>
-#include <mission/system/objects/SyrlinksAssembly.h>
-#include <mission/tmtc/LiveTmTask.h>
-#include <mission/tmtc/PersistentLogTmStoreTask.h>
-#include <mission/tmtc/PersistentSingleTmStoreTask.h>
+#include <mission/system/tcs/TmpDevFdir.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
@@ -61,17 +63,15 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.h"
-#include "mission/system/fdir/GomspacePowerFdir.h"
-#include "mission/system/fdir/RtdFdir.h"
-#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/power/GomspacePowerFdir.h"
+#include "mission/system/tcs/RtdFdir.h"
+#include "mission/system/tcs/TcsBoardAssembly.h"
+#include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
-#include "mission/system/tree/tcsModeTree.h"
 #include "mission/tmtc/tmFilters.h"
 #include "mission/utility/GlobalConfigHandler.h"
 #include "tmtc/pusIds.h"
 
-using gpio::Direction;
-using gpio::Levels;
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
@@ -80,6 +80,7 @@ using gpio::Levels;
 #include <mission/acs/ImtqHandler.h>
 #include <mission/acs/rwHelpers.h>
 #include <mission/com/SyrlinksHandler.h>
+#include <mission/com/VirtualChannelWithQueue.h>
 #include <mission/payload/PayloadPcduHandler.h>
 #include <mission/payload/RadiationSensorHandler.h>
 #include <mission/payload/payloadPcduDefinitions.h>
@@ -95,7 +96,6 @@ using gpio::Levels;
 #include <mission/tcs/Max31865Definitions.h>
 #include <mission/tcs/Max31865PT1000Handler.h>
 #include <mission/tcs/Tmp1075Handler.h>
-#include <mission/tmtc/VirtualChannelWithQueue.h>
 
 #include <sstream>
 
@@ -122,8 +122,12 @@ using gpio::Levels;
 #include "mission/system/acs/AcsBoardAssembly.h"
 #include "mission/tmtc/TmFunnelHandler.h"
 
+using gpio::Direction;
+using gpio::Levels;
+
 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;
 
 void Factory::setStaticFrameworkObjectIds() {
@@ -162,6 +166,7 @@ void ObjectFactory::createTmpComponents() {
         new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
     auto* tmpDevHandler =
         new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[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,
@@ -358,7 +363,8 @@ void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {
 }
 
 void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
-                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
+                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher,
+                                             bool enableHkSets) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
   createAcsBoardGpios(*gpioCookieAcsBoard);
@@ -512,8 +518,8 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
   RESET_ARGS_GNSS.waitPeriodMs = 100;
-  auto gpsCtrl =
-      new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
+  auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
+                                                enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
 
   ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyChildren, gpsCtrl, gpioComIF);
@@ -588,7 +594,7 @@ void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitc
   }
 
   new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, gpioIF, pwrSwitcher,
-                                  pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
+                                  power::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
                                   gpioIds::DEPLSA1, gpioIds::DEPLSA2, *SdCardManager::instance());
 }
 
@@ -604,7 +610,7 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
   auto syrlinksFdir = new SyrlinksFdir(objects::SYRLINKS_HANDLER);
   auto syrlinksHandler =
       new SyrlinksHandler(objects::SYRLINKS_HANDLER, objects::SYRLINKS_COM_HANDLER,
-                          syrlinksUartCookie, pcdu::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
+                          syrlinksUartCookie, power::PDU1_CH1_SYRLINKS_12V, syrlinksFdir);
   syrlinksHandler->setPowerSwitcher(pwrSwitcher);
   syrlinksHandler->connectModeTreeParent(*syrlinksAssy);
 #if OBSW_DEBUG_SYRLINKS == 1
@@ -616,7 +622,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   using namespace gpio;
   std::stringstream consumer;
   auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, pcdu::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::PDU2_CH8_PAYLOAD_CAMERA);
   camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #if OBSW_ADD_PLOC_MPSOC == 1
   consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
@@ -649,7 +655,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
   auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
                                                 Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
-                                                pcdu::PDU1_CH6_PLOC_12V, *supvHelper);
+                                                power::PDU1_CH6_PLOC_12V, *supvHelper);
   supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
   static_cast<void>(consumer);
@@ -726,7 +732,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
     rws[idx] = rwHandler;
   }
 
-  createRwAssy(*pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
+  createRwAssy(*pwrSwitcher, power::Switches::PDU2_CH2_RW_5V, rws, rwIds);
 #endif /* OBSW_ADD_RW == 1 */
 }
 
@@ -751,10 +757,8 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   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);
-  // Initialise to low and then pull high to do a PTME reset, which puts the PTME in reset
-  // state. It will be put out of reset in the CCSDS handler initialize function.
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
-                                    gpio::Direction::OUT, gpio::Levels::LOW);
+                                    gpio::Direction::OUT, gpio::Levels::HIGH);
   gpioCookiePtmeIp->addGpio(gpioIds::PTME_RESETN, gpio);
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
@@ -788,34 +792,42 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
 
   *args.ipCoreHandler =
       new CcsdsIpCoreHandler(objects::CCSDS_HANDLER, objects::CCSDS_PACKET_DISTRIBUTOR, *ptmeConfig,
-                             LINK_STATE, &args.gpioComIF, gpios);
+                             LINK_STATE, &args.gpioComIF, gpios, PTME_LOCKED);
   // This VC will receive all live TM
   auto* vcWithQueue =
       new VirtualChannelWithQueue(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM", *ptme,
                                   LINK_STATE, args.tmStore, 500);
   args.liveDestination = vcWithQueue;
-  new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel, *vcWithQueue);
+  auto* liveTask = new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel,
+                                  *vcWithQueue, PTME_LOCKED);
+  liveTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   // Set up log store.
   auto* vc = new VirtualChannel(objects::PTME_VC1_LOG_TM, ccsds::VC1, "PTME VC1 LOG TM", *ptme,
                                 LINK_STATE);
   LogStores logStores(args.stores);
   // Core task which handles the LOG store and takes care of dumping it as TM using a VC directly
-  new PersistentLogTmStoreTask(objects::LOG_STORE_AND_TM_TASK, args.ipcStore, logStores, *vc,
-                               *SdCardManager::instance());
+  auto* logStore =
+      new PersistentLogTmStoreTask(objects::LOG_STORE_AND_TM_TASK, args.ipcStore, logStores, *vc,
+                                   *SdCardManager::instance(), PTME_LOCKED);
+  logStore->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   vc = new VirtualChannel(objects::PTME_VC2_HK_TM, ccsds::VC2, "PTME VC2 HK TM", *ptme, LINK_STATE);
   // Core task which handles the HK store and takes care of dumping it as TM using a VC directly
-  new PersistentSingleTmStoreTask(objects::HK_STORE_AND_TM_TASK, args.ipcStore,
-                                  *args.stores.hkStore, *vc, persTmStore::DUMP_HK_STORE_DONE,
-                                  persTmStore::DUMP_HK_STORE_DONE, *SdCardManager::instance());
+  auto* hkStore = new PersistentSingleTmStoreTask(
+      objects::HK_STORE_AND_TM_TASK, args.ipcStore, *args.stores.hkStore, *vc,
+      persTmStore::DUMP_HK_STORE_DONE, persTmStore::DUMP_HK_STORE_DONE, *SdCardManager::instance(),
+      PTME_LOCKED);
+  hkStore->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   vc = new VirtualChannel(objects::PTME_VC3_CFDP_TM, ccsds::VC3, "PTME VC3 CFDP TM", *ptme,
                           LINK_STATE);
   // Core task which handles the CFDP store and takes care of dumping it as TM using a VC directly
-  new PersistentSingleTmStoreTask(objects::CFDP_STORE_AND_TM_TASK, args.ipcStore,
-                                  *args.stores.cfdpStore, *vc, persTmStore::DUMP_CFDP_STORE_DONE,
-                                  persTmStore::DUMP_CFDP_CANCELLED, *SdCardManager::instance());
+  auto* cfdpTask = new PersistentSingleTmStoreTask(
+      objects::CFDP_STORE_AND_TM_TASK, args.ipcStore, *args.stores.cfdpStore, *vc,
+      persTmStore::DUMP_CFDP_STORE_DONE, persTmStore::DUMP_CFDP_CANCELLED,
+      *SdCardManager::instance(), PTME_LOCKED);
+  cfdpTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   ReturnValue_t result = (*args.ipCoreHandler)->connectModeTreeParent(satsystem::com::SUBSYSTEM);
   if (result != returnvalue::OK) {
@@ -958,7 +970,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
   auto strFdir = new StrFdir(objects::STAR_TRACKER);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
-                             paramJsonFile, strComIF, pcdu::PDU1_CH2_STAR_TRACKER_5V);
+                             paramJsonFile, strComIF, power::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(*strAssy);
   starTracker->setCustomFdir(strFdir);
@@ -971,7 +983,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
   new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
   I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
   auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
-                                     pcdu::Switches::PDU1_CH3_MGT_5V, enableHkSets);
+                                     power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqHandler->enableThermalModule(ThermalStateCfg());
   imtqHandler->setPowerSwitcher(pwrSwitcher);
   imtqHandler->connectModeTreeParent(*imtqAssy);

bsp_q7s/core/ObjectFactory.h

@@ -4,11 +4,11 @@
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <mission/com/CcsdsIpCoreHandler.h>
+#include <mission/com/PersistentLogTmStoreTask.h>
 #include <mission/genericFactory.h>
 #include <mission/system/objects/Stack5VHandler.h>
 #include <mission/tcs/HeaterHandler.h>
 #include <mission/tmtc/CfdpTmFunnel.h>
-#include <mission/tmtc/PersistentLogTmStoreTask.h>
 #include <mission/tmtc/PusTmFunnel.h>
 
 #include <atomic>
@@ -23,7 +23,7 @@ class HealthTableIF;
 class AcsBoardAssembly;
 class GpioIF;
 
-extern std::atomic_uint16_t I2C_FATAL_ERRORS;
+extern std::atomic_bool PTME_LOCKED;
 
 namespace ObjectFactory {
 
@@ -61,7 +61,7 @@ void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
 void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                              PowerSwitchIF& pwrSwitcher);
+                              PowerSwitchIF& pwrSwitcher, bool enableHkSets);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);

bsp_q7s/core/scheduling.cpp

@@ -237,7 +237,7 @@ void scheduling::initTasks() {
 
 #if OBSW_ADD_RW == 1
   PeriodicTaskIF* rwPolling =
-      factory->createPeriodicTask("RW_POLLING_TASK", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2,
+      factory->createPeriodicTask("RW_POLLING_TASK", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2,
                                   0.4, missedDeadlineFunc, &RR_SCHEDULING);
   result = rwPolling->addComponent(objects::RW_POLLING_TASK);
   if (result != returnvalue::OK) {
@@ -291,9 +291,20 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("STR_ASSY", objects::STR_ASSY);
   }
+  result = acsSysTask->addComponent(objects::GPS_0_HEALTH_DEV);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("GPS_0_HEALTH_DEV", objects::GPS_0_HEALTH_DEV);
+  }
+  result = acsSysTask->addComponent(objects::GPS_1_HEALTH_DEV);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("GPS_1_HEALTH_DEV", objects::GPS_1_HEALTH_DEV);
+  }
 
   PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
       "TCS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);
+#if OBSW_ADD_THERMAL_TEMP_INSERTER == 1
+  tcsSystemTask->addComponent(objects::THERMAL_TEMP_INSERTER);
+#endif
   scheduling::scheduleRtdSensors(tcsSystemTask);
   result = tcsSystemTask->addComponent(objects::TCS_SUBSYSTEM);
   if (result != returnvalue::OK) {
@@ -309,12 +320,10 @@ void scheduling::initTasks() {
     scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
   }
 #endif
-#if OBSW_ADD_HEATERS == 1
   result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
   }
-#endif
 
 #if OBSW_ADD_SYRLINKS == 1
   PeriodicTaskIF* syrlinksCom = factory->createPeriodicTask(
@@ -530,7 +539,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
 
   FixedTimeslotTaskIF* gomSpacePstTask =
       factory.createFixedTimeslotTask("GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4,
-                                      0.5, missedDeadlineFunc, &RR_SCHEDULING);
+                                      0.25, missedDeadlineFunc, &RR_SCHEDULING);
   result = pst::pstGompaceCan(gomSpacePstTask);
   if (result != returnvalue::OK) {
     if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {

bsp_q7s/em/emObjectFactory.cpp

@@ -5,7 +5,7 @@
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <mission/power/gsDefs.h>
-#include <mission/system/tree/system.h>
+#include <mission/system/systemTree.h>
 #include <mission/utility/DummySdCardManager.h>
 
 #include "OBSWConfig.h"
@@ -13,7 +13,7 @@
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
 #include "devConf.h"
-#include "dummies/helpers.h"
+#include "dummies/helperFactory.h"
 #include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
@@ -63,15 +63,15 @@ void ObjectFactory::produce(void* args) {
 
   PowerSwitchIF* pwrSwitcher = nullptr;
 #if OBSW_ADD_GOMSPACE_PCDU == 0
-  auto* comCookieDummy = new ComCookieDummy();
-  pwrSwitcher = new PcduHandlerDummy(objects::PCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  pwrSwitcher = new PcduHandlerDummy(objects::PCDU_HANDLER);
 #else
   createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
 #endif
+  satsystem::EIVE_SYSTEM.setI2cRecoveryParams(pwrSwitcher);
 
   dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF);
 
-  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS, enableHkSets);
+  new CoreController(objects::CORE_CONTROLLER, enableHkSets);
 
   // Regular FM code, does not work for EM if the hardware is not connected
   // createPcduComponents(gpioComIF, &pwrSwitcher);
@@ -137,8 +137,8 @@ void ObjectFactory::produce(void* args) {
                        pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   createAcsController(true, enableHkSets);
-  HeaterHandler* heaterHandler = nullptr;
-  ObjectFactory::createGenericHeaterComponents(*gpioComIF, *pwrSwitcher, heaterHandler);
+  HeaterHandler* heaterHandler;
+  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
   createThermalController(*heaterHandler);
   satsystem::init();
 }

bsp_q7s/fmObjectFactory.cpp

@@ -2,6 +2,7 @@
 #include <fsfw/storagemanager/LocalPool.h>
 #include <fsfw/storagemanager/PoolManager.h>
 #include <mission/power/gsDefs.h>
+#include <mission/system/EiveSystem.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
@@ -13,7 +14,7 @@
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/genericFactory.h"
-#include "mission/system/tree/system.h"
+#include "mission/system/systemTree.h"
 #include "mission/tmtc/tmFilters.h"
 
 void ObjectFactory::produce(void* args) {
@@ -43,8 +44,10 @@ void ObjectFactory::produce(void* args) {
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
 
-  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS, enableHkSets);
+  new CoreController(objects::CORE_CONTROLLER, enableHkSets);
   createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
+  satsystem::EIVE_SYSTEM.setI2cRecoveryParams(pwrSwitcher);
+
   auto* stackHandler = new Stack5VHandler(*pwrSwitcher);
 
 #if OBSW_ADD_RAD_SENSORS == 1
@@ -55,7 +58,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true);
 #endif
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
@@ -97,7 +100,7 @@ void ObjectFactory::produce(void* args) {
 
 #if OBSW_ADD_SCEX_DEVICE == 1
   createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
-                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
+                       power::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1

bsp_q7s/fs/SdCardManager.cpp

@@ -309,32 +309,6 @@ void SdCardManager::resetState() {
   currentOp = Operations::IDLE;
 }
 
-ReturnValue_t SdCardManager::updateSdStatePair() {
-  using namespace std;
-
-  std::error_code e;
-  if (not filesystem::exists(SD_STATE_FILE, e)) {
-    return STATUS_FILE_NEXISTS;
-  }
-
-  // Now the file should exist in any case. Still check whether it exists.
-  fstream sdStatus(SD_STATE_FILE);
-  if (not sdStatus.good()) {
-    return STATUS_FILE_NEXISTS;
-  }
-  string line;
-  uint8_t idx = 0;
-  sd::SdCard currentSd = sd::SdCard::SLOT_0;
-  // Process status file line by line
-  while (std::getline(sdStatus, line)) {
-    processSdStatusLine(line, idx, currentSd);
-  }
-  if (sdStates.first != sd::SdState::MOUNTED && sdStates.second != sd::SdState::MOUNTED) {
-    sdCardActive = false;
-  }
-  return returnvalue::OK;
-}
-
 void SdCardManager::processSdStatusLine(std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
   using namespace std;
   istringstream iss(line);
@@ -407,6 +381,7 @@ ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) {
 }
 
 ReturnValue_t SdCardManager::updateSdCardStateFile() {
+  using namespace std;
   if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
     return CommandExecutor::COMMAND_PENDING;
   }
@@ -414,10 +389,31 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() {
   std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
   cmdExecutor.load(updateCmd, true, printCmdOutput);
   ReturnValue_t result = cmdExecutor.execute();
-  if (blocking and result != returnvalue::OK) {
+  if (result != returnvalue::OK) {
     utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
   }
-  return result;
+
+  std::error_code e;
+  if (not filesystem::exists(SD_STATE_FILE, e)) {
+    return STATUS_FILE_NEXISTS;
+  }
+
+  // Now the file should exist in any case. Still check whether it exists.
+  fstream sdStatus(SD_STATE_FILE);
+  if (not sdStatus.good()) {
+    return STATUS_FILE_NEXISTS;
+  }
+  string line;
+  uint8_t idx = 0;
+  sd::SdCard currentSd = sd::SdCard::SLOT_0;
+  // Process status file line by line
+  while (std::getline(sdStatus, line)) {
+    processSdStatusLine(line, idx, currentSd);
+  }
+  if (sdStates.first != sd::SdState::MOUNTED && sdStates.second != sd::SdState::MOUNTED) {
+    sdCardActive = false;
+  }
+  return returnvalue::OK;
 }
 
 const char* SdCardManager::getCurrentMountPrefix() const {
@@ -585,3 +581,8 @@ void SdCardManager::markUnusable() {
   MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
   markedUnusable = true;
 }
+
+void SdCardManager::markUsable() {
+  MutexGuard mg(defaultLock, LOCK_TYPE, OTHER_TIMEOUT, LOCK_CTX);
+  markedUnusable = false;
+}

bsp_q7s/fs/SdCardManager.h

@@ -117,16 +117,6 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   ReturnValue_t switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard = true,
                                 SdStatePair* statusPair = nullptr);
 
-  /**
-   * Update the state file or creates one if it does not exist. You need to call this
-   * function before calling #sdCardActive
-   * @return
-   *  - returnvalue::OK if the state file was updated successfully
-   *  - CommandExecutor::COMMAND_PENDING: Non-blocking command is pending
-   *  - returnvalue::FAILED: blocking command failed
-   */
-  ReturnValue_t updateSdCardStateFile();
-
   /**
    * Get the state of the SD cards. If the state file does not exist, this function will
    * take care of updating it. If it does not, the function will use the state file to get
@@ -215,6 +205,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   ReturnValue_t performFsck(sd::SdCard sdcard, bool printOutput, int& linuxError);
 
   void markUnusable();
+  void markUsable();
 
  private:
   CommandExecutor cmdExecutor;
@@ -234,7 +225,15 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
 
   SdCardManager();
 
-  ReturnValue_t updateSdStatePair();
+  /**
+   * Update the state file or creates one if it does not exist. You need to call this
+   * function before calling #sdCardActive
+   * @return
+   *  - returnvalue::OK if the state file was updated successfully
+   *  - CommandExecutor::COMMAND_PENDING: Non-blocking command is pending
+   *  - returnvalue::FAILED: blocking command failed
+   */
+  ReturnValue_t updateSdCardStateFile();
 
   ReturnValue_t setSdCardState(sd::SdCard sdCard, bool on);
 

bsp_q7s/obsw.cpp

@@ -16,7 +16,7 @@
 #include "fsfw/version.h"
 #include "mission/acs/defs.h"
 #include "mission/com/defs.h"
-#include "mission/system/tree/system.h"
+#include "mission/system/systemTree.h"
 #include "q7sConfig.h"
 #include "watchdog/definitions.h"
 

common/config/eive/definitions.h

@@ -15,6 +15,9 @@ static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
 
+// ISO8601 timestamp.
+static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
+
 static constexpr uint16_t EIVE_PUS_APID = 0x65;
 static constexpr uint16_t EIVE_CFDP_APID = 0x66;
 static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;

common/config/eive/objects.h

@@ -43,6 +43,8 @@ enum commonObjects : uint32_t {
   RW4 = 0x44120350,
   STAR_TRACKER = 0x44130001,
   GPS_CONTROLLER = 0x44130045,
+  GPS_0_HEALTH_DEV = 0x44130046,
+  GPS_1_HEALTH_DEV = 0x44130047,
 
   IMTQ_POLLING = 0x44140013,
   IMTQ_HANDLER = 0x44140014,

common/config/eive/resultClassIds.h

@@ -37,9 +37,6 @@ enum commonClassIds : uint8_t {
   SUPV_RETURN_VALUES_IF,    // SPVRTVIF
   ACS_CTRL,                 // ACSCTRL
   ACS_MEKF,                 // ACSMEKF
-  ACS_SAFE,                 // ACSSAF
-  ACS_PTG,                  // ACSPTG
-  ACS_DETUMBLE,             // ACSDTB
   SD_CARD_MANAGER,          // SDMA
   LOCAL_PARAM_HANDLER,      // LPH
   PERSISTENT_TM_STORE,      // PTM

dummies/BpxDummy.cpp

@@ -37,19 +37,19 @@ uint32_t BpxDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t BpxDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_1, &battTemp1);
-  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_2, &battTemp2);
-  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_3, &battTemp3);
-  localDataPoolMap.emplace(BpxBattery::BATT_TEMP_4, &battTemp4);
-  localDataPoolMap.emplace(BpxBattery::CHARGE_CURRENT, &chargeCurrent);
-  localDataPoolMap.emplace(BpxBattery::DISCHARGE_CURRENT, &dischargeCurrent);
-  localDataPoolMap.emplace(BpxBattery::HEATER_CURRENT, &heaterCurrent);
-  localDataPoolMap.emplace(BpxBattery::BATT_VOLTAGE, &battVolt);
-  localDataPoolMap.emplace(BpxBattery::REBOOT_COUNTER, &rebootCounter);
-  localDataPoolMap.emplace(BpxBattery::BOOTCAUSE, &bootCause);
+  localDataPoolMap.emplace(bpxBat::BATT_TEMP_1, &battTemp1);
+  localDataPoolMap.emplace(bpxBat::BATT_TEMP_2, &battTemp2);
+  localDataPoolMap.emplace(bpxBat::BATT_TEMP_3, &battTemp3);
+  localDataPoolMap.emplace(bpxBat::BATT_TEMP_4, &battTemp4);
+  localDataPoolMap.emplace(bpxBat::CHARGE_CURRENT, &chargeCurrent);
+  localDataPoolMap.emplace(bpxBat::DISCHARGE_CURRENT, &dischargeCurrent);
+  localDataPoolMap.emplace(bpxBat::HEATER_CURRENT, &heaterCurrent);
+  localDataPoolMap.emplace(bpxBat::BATT_VOLTAGE, &battVolt);
+  localDataPoolMap.emplace(bpxBat::REBOOT_COUNTER, &rebootCounter);
+  localDataPoolMap.emplace(bpxBat::BOOTCAUSE, &bootCause);
 
-  localDataPoolMap.emplace(BpxBattery::BATTERY_HEATER_MODE, &battheatMode);
-  localDataPoolMap.emplace(BpxBattery::BATTHEAT_LOW_LIMIT, &battheatLow);
-  localDataPoolMap.emplace(BpxBattery::BATTHEAT_HIGH_LIMIT, &battheatHigh);
+  localDataPoolMap.emplace(bpxBat::BATTERY_HEATER_MODE, &battheatMode);
+  localDataPoolMap.emplace(bpxBat::BATTHEAT_LOW_LIMIT, &battheatLow);
+  localDataPoolMap.emplace(bpxBat::BATTHEAT_HIGH_LIMIT, &battheatHigh);
   return returnvalue::OK;
 }

dummies/CMakeLists.txt

@@ -26,6 +26,6 @@ target_sources(
          CoreControllerDummy.cpp
          PlocMpsocDummy.cpp
          PlocSupervisorDummy.cpp
-         helpers.cpp
+         helperFactory.cpp
          MgmRm3100Dummy.cpp
          Tmp1075Dummy.cpp)

dummies/GyroAdisDummy.cpp

@@ -46,7 +46,7 @@ ReturnValue_t GyroAdisDummy::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(adis1650x::ACCELERATION_X, new PoolEntry<double>({0.0}));
   localDataPoolMap.emplace(adis1650x::ACCELERATION_Y, new PoolEntry<double>({0.0}));
   localDataPoolMap.emplace(adis1650x::ACCELERATION_Z, new PoolEntry<double>({0.0}));
-  localDataPoolMap.emplace(adis1650x::TEMPERATURE, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(adis1650x::TEMPERATURE, new PoolEntry<float>({10.0}, true));
 
   return returnvalue::OK;
 }

dummies/ImtqDummy.cpp

@@ -43,5 +43,7 @@ ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataP
   localDataPoolMap.emplace(imtq::ACTUATION_CAL_STATUS, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(imtq::MTM_RAW, new PoolEntry<float>({0.12, 0.76, -0.45}, true));
   localDataPoolMap.emplace(imtq::ACTUATION_RAW_STATUS, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(imtq::DIPOLES_ID, new PoolEntry<int16_t>({0, 0, 0}));
+  localDataPoolMap.emplace(imtq::CURRENT_TORQUE_DURATION, new PoolEntry<uint16_t>({0}));
   return DeviceHandlerBase::initializeLocalDataPool(localDataPoolMap, poolManager);
 }

dummies/Max31865Dummy.cpp

@@ -1,5 +1,7 @@
 #include "Max31865Dummy.h"
 
+#include "fsfw/datapool/PoolReadGuard.h"
+
 using namespace returnvalue;
 
 Max31865Dummy::Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
@@ -28,15 +30,20 @@ ReturnValue_t Max31865Dummy::initializeLocalDataPool(localpool::DataPool &localD
                                                      LocalDataPoolManager &poolManager) {
   using namespace MAX31865;
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::RTD_VALUE), new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C), new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::TEMPERATURE_C),
+                           new PoolEntry<float>({10.0}, true));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::LAST_FAULT_BYTE),
                            new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(static_cast<lp_id_t>(PoolIds::FAULT_BYTE), new PoolEntry<uint8_t>({0}));
   return OK;
 }
 
-void Max31865Dummy::setTemperature(float temperature) {
-  set.temperatureCelcius.value = temperature;
+void Max31865Dummy::setTemperature(float temperature, bool valid) {
+  PoolReadGuard pg(&set);
+  if (pg.getReadResult() == returnvalue::OK) {
+    set.temperatureCelcius.value = temperature;
+    set.setValidity(valid, true);
+  }
 }
 
 LocalPoolDataSetBase *Max31865Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Max31865Dummy.h

@@ -10,7 +10,7 @@ class Max31865Dummy : public DeviceHandlerBase {
   Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
   Max31865Dummy(object_id_t objectId, CookieIF *comCookie);
 
-  void setTemperature(float temperature);
+  void setTemperature(float temperature, bool setValid);
 
  private:
   MAX31865::PrimarySet set;

dummies/MgmLIS3MDLDummy.cpp

@@ -40,7 +40,7 @@ uint32_t MgmLIS3MDLDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
 
 ReturnValue_t MgmLIS3MDLDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                        LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, new PoolEntry<float>({10.0}, true));
   localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS,
                            new PoolEntry<float>({1.02, 0.56, -0.78}, true));
   return returnvalue::OK;

dummies/P60DockDummy.cpp

@@ -2,6 +2,8 @@
 
 #include <mission/power/gsDefs.h>
 
+#include "fsfw/datapool/PoolReadGuard.h"
+
 P60DockDummy::P60DockDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}
 

dummies/P60DockDummy.h

@@ -3,6 +3,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/power/gsDefs.h"
+
 class P60DockDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@@ -15,6 +17,8 @@ class P60DockDummy : public DeviceHandlerBase {
   virtual ~P60DockDummy();
 
  protected:
+  lp_var_t<float> temp1 = lp_var_t<float>(this, P60Dock::pool::P60DOCK_TEMPERATURE_1);
+  lp_var_t<float> temp2 = lp_var_t<float>(this, P60Dock::pool::P60DOCK_TEMPERATURE_2);
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/PcduHandlerDummy.cpp

@@ -1,49 +1,35 @@
 #include "PcduHandlerDummy.h"
 
+#include <fsfw/ipc/QueueFactory.h>
 #include <mission/power/gsDefs.h>
 
-PcduHandlerDummy::PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie), dummySwitcher(objectId, 18, 18, false) {}
+#include "mission/power/defs.h"
+
+PcduHandlerDummy::PcduHandlerDummy(object_id_t objectId)
+    : SystemObject(objectId), manager(this, nullptr), dummySwitcher(objectId, 18, 18, false) {
+  switcherLock = MutexFactory::instance()->createMutex();
+  queue = QueueFactory::instance()->createMessageQueue(20);
+}
 
 PcduHandlerDummy::~PcduHandlerDummy() {}
 
-void PcduHandlerDummy::doStartUp() { setMode(MODE_NORMAL); }
-
-void PcduHandlerDummy::doShutDown() { setMode(MODE_OFF); }
-
-ReturnValue_t PcduHandlerDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
-
-ReturnValue_t PcduHandlerDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
-
-ReturnValue_t PcduHandlerDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                        const uint8_t *commandData,
-                                                        size_t commandDataLen) {
-  return returnvalue::OK;
-}
-
-ReturnValue_t PcduHandlerDummy::scanForReply(const uint8_t *start, size_t len,
-                                             DeviceCommandId_t *foundId, size_t *foundLen) {
-  return returnvalue::OK;
-}
-
-ReturnValue_t PcduHandlerDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return returnvalue::OK;
-}
-
-void PcduHandlerDummy::fillCommandAndReplyMap() {}
-
-uint32_t PcduHandlerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
-
-ReturnValue_t PcduHandlerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                        LocalDataPoolManager &poolManager) {
+ReturnValue_t PcduHandlerDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                        LocalDataPoolManager& poolManager) {
   return returnvalue::OK;
 }
 
 ReturnValue_t PcduHandlerDummy::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
+  if (onOff == SWITCH_ON) {
+    triggerEvent(power::SWITCH_CMD_SENT, true, switchNr);
+  } else {
+    triggerEvent(power::SWITCH_CMD_SENT, false, switchNr);
+  }
+  {
+    MutexGuard mg(switcherLock);
+    // To simulate a real PCDU, remember the switch change to trigger a SWITCH_HAS_CHANGED event
+    // at a later stage.
+    switchChangeArray[switchNr] = true;
+  }
   return dummySwitcher.sendSwitchCommand(switchNr, onOff);
 }
 
@@ -60,3 +46,37 @@ ReturnValue_t PcduHandlerDummy::getFuseState(uint8_t fuseNr) const {
 }
 
 uint32_t PcduHandlerDummy::getSwitchDelayMs(void) const { return dummySwitcher.getSwitchDelayMs(); }
+
+ReturnValue_t PcduHandlerDummy::performOperation(uint8_t opCode) {
+  // TODO: Handle HK messages in queue.
+  SwitcherBoolArray switcherChangeCopy{};
+  {
+    MutexGuard mg(switcherLock);
+    std::memcpy(switcherChangeCopy.data(), switchChangeArray.data(), switchChangeArray.size());
+  }
+  for (uint8_t idx = 0; idx < switcherChangeCopy.size(); idx++) {
+    if (switcherChangeCopy[idx]) {
+      if (dummySwitcher.getSwitchState(idx) == PowerSwitchIF::SWITCH_ON) {
+        triggerEvent(power::SWITCH_HAS_CHANGED, true, idx);
+      } else {
+        triggerEvent(power::SWITCH_HAS_CHANGED, false, idx);
+      }
+      MutexGuard mg(switcherLock);
+      switchChangeArray[idx] = false;
+    }
+  }
+  return returnvalue::OK;
+}
+
+object_id_t PcduHandlerDummy::getObjectId() const { return SystemObject::getObjectId(); }
+
+MessageQueueId_t PcduHandlerDummy::getCommandQueue() const { return queue->getId(); }
+
+dur_millis_t PcduHandlerDummy::getPeriodicOperationFrequency() const {
+  // TODO: dummy value. Retrieve from intiitalize after task creation..
+  return 400;
+}
+
+LocalDataPoolManager* PcduHandlerDummy::getHkManagerHandle() { return &manager; }
+
+LocalPoolDataSetBase* PcduHandlerDummy::getDataSetHandle(sid_t sid) { return nullptr; }

dummies/PcduHandlerDummy.h

@@ -3,7 +3,10 @@
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/power/DummyPowerSwitcher.h>
 
-class PcduHandlerDummy : public DeviceHandlerBase, public PowerSwitchIF {
+class PcduHandlerDummy : public PowerSwitchIF,
+                         public HasLocalDataPoolIF,
+                         public SystemObject,
+                         public ExecutableObjectIF {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;
   static const DeviceCommandId_t PERIODIC_REPLY = 2;
@@ -11,29 +14,49 @@ class PcduHandlerDummy : public DeviceHandlerBase, public PowerSwitchIF {
   static const uint8_t SIMPLE_COMMAND_DATA = 1;
   static const uint8_t PERIODIC_REPLY_DATA = 2;
 
-  PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  PcduHandlerDummy(object_id_t objectId);
   virtual ~PcduHandlerDummy();
 
  protected:
+  MessageQueueIF* queue;
+  LocalDataPoolManager manager;
+  MutexIF* switcherLock;
   DummyPowerSwitcher dummySwitcher;
+  using SwitcherBoolArray = std::array<bool, 18>;
 
-  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;
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  SwitcherBoolArray switchChangeArray{};
+
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
 
   ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
   ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
   ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
   ReturnValue_t getFuseState(uint8_t fuseNr) const override;
   uint32_t getSwitchDelayMs(void) const override;
+
+  object_id_t getObjectId() const override;
+
+  /** Command queue for housekeeping messages. */
+  MessageQueueId_t getCommandQueue() const override;
+
+  dur_millis_t getPeriodicOperationFrequency() const override;
+
+  /**
+   * Every class implementing this interface should have a local data pool manager. This
+   * function will return a reference to the manager.
+   * @return
+   */
+  LocalDataPoolManager* getHkManagerHandle() override;
+
+  /**
+   * This function is used by the pool manager to get a valid dataset
+   * from a SID. This function is protected to prevent users from
+   * using raw data set pointers which could not be thread-safe. Users
+   * should use the #ProvidesDataPoolSubscriptionIF.
+   * @param sid Corresponding structure ID
+   * @return
+   */
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 };

dummies/PlocMpsocDummy.h

@@ -2,6 +2,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/power/defs.h"
+
 class PlocMpsocDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;

dummies/PlocSupervisorDummy.cpp

@@ -1,8 +1,10 @@
 #include "PlocSupervisorDummy.h"
 
 PlocSupervisorDummy::PlocSupervisorDummy(object_id_t objectId, object_id_t comif,
-                                         CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+                                         CookieIF *comCookie, PowerSwitchIF &pwrSwitcher)
+    : DeviceHandlerBase(objectId, comif, comCookie) {
+  setPowerSwitcher(&pwrSwitcher);
+}
 
 PlocSupervisorDummy::~PlocSupervisorDummy() {}
 
@@ -42,3 +44,10 @@ ReturnValue_t PlocSupervisorDummy::initializeLocalDataPool(localpool::DataPool &
                                                            LocalDataPoolManager &poolManager) {
   return returnvalue::OK;
 }
+
+ReturnValue_t PlocSupervisorDummy::getSwitches(const uint8_t **switches,
+                                               uint8_t *numberOfSwitches) {
+  *numberOfSwitches = 1;
+  *switches = reinterpret_cast<const uint8_t *>(&switchId);
+  return returnvalue::OK;
+}

dummies/PlocSupervisorDummy.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/power/defs.h>
 
 class PlocSupervisorDummy : public DeviceHandlerBase {
  public:
@@ -10,10 +11,13 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
   static const uint8_t SIMPLE_COMMAND_DATA = 1;
   static const uint8_t PERIODIC_REPLY_DATA = 2;
 
-  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
+                      PowerSwitchIF &pwrSwitcher);
   virtual ~PlocSupervisorDummy();
 
  protected:
+  const power::Switches switchId = power::Switches::PDU1_CH6_PLOC_12V;
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
@@ -27,4 +31,5 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
 };

dummies/RwDummy.cpp

@@ -7,9 +7,9 @@ RwDummy::RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
 
 RwDummy::~RwDummy() {}
 
-void RwDummy::doStartUp() {}
+void RwDummy::doStartUp() { setMode(MODE_ON); }
 
-void RwDummy::doShutDown() {}
+void RwDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
@@ -37,6 +37,9 @@ uint32_t RwDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(rws::RW_SPEED, &rwSpeed);
+  localDataPoolMap.emplace(rws::RAMP_TIME, &rampTime);
+
   localDataPoolMap.emplace(rws::TEMPERATURE_C, new PoolEntry<int32_t>({0}));
 
   localDataPoolMap.emplace(rws::CURR_SPEED, new PoolEntry<int32_t>({0}));

dummies/RwDummy.h

@@ -15,6 +15,9 @@ class RwDummy : public DeviceHandlerBase {
   virtual ~RwDummy();
 
  protected:
+  PoolEntry<int32_t> rwSpeed = PoolEntry<int32_t>({0});
+  PoolEntry<uint16_t> rampTime = PoolEntry<uint16_t>({10});
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/StarTrackerDummy.cpp

@@ -7,9 +7,9 @@ StarTrackerDummy::StarTrackerDummy(object_id_t objectId, object_id_t comif, Cook
 
 StarTrackerDummy::~StarTrackerDummy() {}
 
-void StarTrackerDummy::doStartUp() {}
+void StarTrackerDummy::doStartUp() { setMode(MODE_ON); }
 
-void StarTrackerDummy::doShutDown() {}
+void StarTrackerDummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
 
 ReturnValue_t StarTrackerDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
@@ -40,7 +40,7 @@ uint32_t StarTrackerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo)
 
 ReturnValue_t StarTrackerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                         LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(startracker::MCU_TEMPERATURE, new PoolEntry<float>({10.0}, true));
 
   localDataPoolMap.emplace(startracker::TICKS_SOLUTION_SET, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(startracker::TIME_SOLUTION_SET, new PoolEntry<uint64_t>({0}));
@@ -64,6 +64,7 @@ ReturnValue_t StarTrackerDummy::initializeLocalDataPool(localpool::DataPool &loc
   localDataPoolMap.emplace(startracker::LISA_NR_CLOSE, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(startracker::TRUST_WORTHY, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(startracker::STABLE_COUNT, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(startracker::STR_MODE, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(startracker::SOLUTION_STRATEGY, new PoolEntry<uint8_t>({0}));
   return returnvalue::OK;
 }

dummies/SyrlinksDummy.cpp

@@ -40,7 +40,7 @@ uint32_t SyrlinksDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { r
 
 ReturnValue_t SyrlinksDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                      LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(syrlinks::TEMP_BASEBAND_BOARD, new PoolEntry<float>({10}, true));
+  localDataPoolMap.emplace(syrlinks::TEMP_POWER_AMPLIFIER, new PoolEntry<float>({10}, true));
   return returnvalue::OK;
 }

dummies/TemperatureSensorInserter.cpp

@@ -1,5 +1,6 @@
 #include "TemperatureSensorInserter.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <objects/systemObjectList.h>
 
 #include <cmath>
@@ -9,32 +10,104 @@
 TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
                                                      Max31865DummyMap tempSensorDummies_,
                                                      Tmp1075DummyMap tempTmpSensorDummies_)
-    : SystemObject(objects::THERMAL_TEMP_INSERTER),
+    : SystemObject(objectId),
       max31865DummyMap(std::move(tempSensorDummies_)),
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
 
 ReturnValue_t TemperatureSensorInserter::initialize() {
-  if (performTest) {
-    if (testCase == TestCase::COOL_SYRLINKS) {
-    }
-  }
+  testCase = TestCase::NONE;
   return returnvalue::OK;
 }
 
 ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
-  /*
-  ReturnValue_t result = max31865PlocHeatspreaderSet.read();
-  if (result != returnvalue::OK) {
-    sif::warning << "Failed to read temperature from MAX31865 dataset" << std::endl;
+  // TODO: deviceSensors
+  if (not tempsWereInitialized) {
+    for (auto& rtdDummy : max31865DummyMap) {
+      rtdDummy.second->setTemperature(10, true);
+    }
+    for (auto& tmpDummy : tmp1075DummyMap) {
+      tmpDummy.second->setTemperature(10, true);
+    }
+    tempsWereInitialized = true;
   }
-  max31865PlocHeatspreaderSet.rtdValue = value - 5;
-  max31865PlocHeatspreaderSet.temperatureCelcius = value;
-  if ((iteration % 100) < 20) {
-    max31865PlocHeatspreaderSet.setValidity(false, true);
-  } else {
-    max31865PlocHeatspreaderSet.setValidity(true, true);
+
+  switch (testCase) {
+    case (TestCase::NONE): {
+      break;
+    }
+    case (TestCase::COLD_SYRLINKS): {
+      // TODO: How do I insert this?
+      // Does not work on EM, where a real syrlinks device is connected.
+      if (cycles == 15) {
+        lp_var_t<float> tempSyrlinksBasebandBoard =
+            lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
+        PoolReadGuard pg(&tempSyrlinksBasebandBoard);
+        tempSyrlinksBasebandBoard.value = -50;
+      }
+      if (cycles == 30) {
+        lp_var_t<float> tempSyrlinksBasebandBoard =
+            lp_var_t<float>(objects::SYRLINKS_HANDLER, syrlinks::TEMP_BASEBAND_BOARD);
+        PoolReadGuard pg(&tempSyrlinksBasebandBoard);
+        tempSyrlinksBasebandBoard.value = 0;
+      }
+      break;
+    }
+    case (TestCase::COLD_HPA): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold HPA temperature" << std::endl;
+        max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(-60, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting HPA temperature back to normal" << std::endl;
+        max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(0, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_MGT): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold MGT temperature" << std::endl;
+        max31865DummyMap[objects::RTD_15_IC18_IMTQ]->setTemperature(-60, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting MGT temperature back to normal" << std::endl;
+        max31865DummyMap[objects::RTD_15_IC18_IMTQ]->setTemperature(0, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_STR):
+    case (TestCase::COLD_STR_CONSECUTIVE): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold STR temperature" << std::endl;
+        max31865DummyMap[objects::RTD_4_IC7_STARTRACKER]->setTemperature(-40, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting STR temperature back to normal" << std::endl;
+        max31865DummyMap[objects::RTD_4_IC7_STARTRACKER]->setTemperature(0, true);
+      }
+      if (testCase == TestCase::COLD_STR_CONSECUTIVE) {
+        if (cycles == 45) {
+          sif::debug << "Setting cold STR temperature again" << std::endl;
+          max31865DummyMap[objects::RTD_4_IC7_STARTRACKER]->setTemperature(-40, true);
+        }
+        if (cycles == 60) {
+          sif::debug << "Setting STR temperature back to normal again" << std::endl;
+          max31865DummyMap[objects::RTD_4_IC7_STARTRACKER]->setTemperature(0, true);
+        }
+      }
+      break;
+    }
+    case (TestCase::COLD_CAMERA): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold CAM temperature" << std::endl;
+        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-40, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting CAM temperature back to normal" << std::endl;
+        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(0, true);
+      }
+    }
   }
-  max31865PlocHeatspreaderSet.commit();
-  */
+  cycles++;
   return returnvalue::OK;
 }
+ReturnValue_t TemperatureSensorInserter::initializeAfterTaskCreation() { return returnvalue::OK; }

dummies/TemperatureSensorInserter.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fsfw/controller/ExtendedControllerBase.h>
+#include <mission/com/syrlinksDefs.h>
 #include <mission/tcs/Max31865Definitions.h>
 
 #include "Max31865Dummy.h"
@@ -14,6 +15,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
                                      Tmp1075DummyMap tempTmpSensorDummies_);
 
   ReturnValue_t initialize() override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   ReturnValue_t performOperation(uint8_t opCode) override;
@@ -21,9 +23,19 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
  private:
   Max31865DummyMap max31865DummyMap;
   Tmp1075DummyMap tmp1075DummyMap;
-  enum TestCase { NONE = 0, COOL_SYRLINKS = 1 };
+
+  enum TestCase {
+    NONE = 0,
+    COLD_SYRLINKS = 1,
+    COLD_HPA = 2,
+    COLD_MGT = 3,
+    COLD_STR = 4,
+    COLD_STR_CONSECUTIVE = 5,
+    COLD_CAMERA = 6,
+  };
   int iteration = 0;
-  bool performTest = false;
+  uint32_t cycles = 0;
+  bool tempsWereInitialized = false;
   TestCase testCase = TestCase::NONE;
 
   // void noise();

dummies/Tmp1075Dummy.cpp

@@ -1,5 +1,6 @@
 #include "Tmp1075Dummy.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/tcs/Tmp1075Definitions.h>
 
 using namespace returnvalue;
@@ -26,11 +27,16 @@ ReturnValue_t Tmp1075Dummy::scanForReply(const uint8_t *start, size_t len,
 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>({0.0}));
+  localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075, new PoolEntry<float>({10.0}, true));
   return OK;
 }
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }

dummies/Tmp1075Dummy.h

@@ -8,6 +8,7 @@
 class Tmp1075Dummy : public DeviceHandlerBase {
  public:
   Tmp1075Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  void setTemperature(float temperature, bool setValid);
 
  private:
   TMP1075::Tmp1075Dataset set;

dummies/helperFactory.cpp

@@ -1,4 +1,4 @@
-#include "helpers.h"
+#include "helperFactory.h"
 
 #include <dummies/AcuDummy.h>
 #include <dummies/BpxDummy.h>
@@ -24,12 +24,13 @@
 #include <dummies/StarTrackerDummy.h>
 #include <dummies/SusDummy.h>
 #include <dummies/SyrlinksDummy.h>
+#include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <mission/power/gsDefs.h>
 #include <mission/system/acs/ImtqAssembly.h>
+#include <mission/system/acs/StrAssembly.h>
 #include <mission/system/objects/CamSwitcher.h>
-#include <mission/system/objects/StrAssembly.h>
-#include <mission/system/objects/TcsBoardAssembly.h>
+#include <mission/system/tcs/TcsBoardAssembly.h>
 
 #include "TemperatureSensorInserter.h"
 #include "dummies/Max31865Dummy.h"
@@ -37,8 +38,9 @@
 #include "mission/genericFactory.h"
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/comModeTree.h"
+#include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
-#include "mission/system/tree/tcsModeTree.h"
+#include "mission/tcs/defs.h"
 
 void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF) {
   new ComIFDummy(objects::DUMMY_COM_IF);
@@ -56,7 +58,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   rws[1] = new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
   rws[2] = new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
   rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
-  ObjectFactory::createRwAssy(pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
+  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);
@@ -192,16 +194,19 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_PLPCDU_0,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tmpSensorDummies.emplace(
-        objects::TMP1075_HANDLER_PLPCDU_1,
-        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, 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));
 
     new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
                                   tmpSensorDummies);
-    TcsBoardAssembly* tcsBoardAssy = ObjectFactory::createTcsBoardAssy(pwrSwitcher);
+    TcsBoardAssembly* tcsBoardAssy =
+        ObjectFactory::createTcsBoardAssy(pwrSwitcher, tcs::TCS_BOARD_SHORTLY_UNAVAILABLE);
     for (auto& rtd : rtdSensorDummies) {
       rtd.second->connectModeTreeParent(*tcsBoardAssy);
     }
@@ -210,7 +215,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     }
   }
   auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, pcdu::Switches::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, 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);
@@ -221,8 +226,8 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     auto* plocMpsocDummy =
         new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     plocMpsocDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
-    auto* plocSupervisorDummy = new PlocSupervisorDummy(objects::PLOC_SUPERVISOR_HANDLER,
-                                                        objects::DUMMY_COM_IF, comCookieDummy);
+    auto* plocSupervisorDummy = new PlocSupervisorDummy(
+        objects::PLOC_SUPERVISOR_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, pwrSwitcher);
     plocSupervisorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   }
 }

generators/bsp_hosted_events.csv

@@ -86,13 +86,14 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
-11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;No description;mission/acs/defs.h
-11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;No description;mission/acs/defs.h
-11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;No description;mission/acs/defs.h
-11203;0x2bc3;MEKF_INVALID_INFO;INFO;No description;mission/acs/defs.h
-11204;0x2bc4;MEKF_RECOVERY;INFO;No description;mission/acs/defs.h
-11205;0x2bc5;MEKF_INVALID_MODE_VIOLATION;HIGH;No description;mission/acs/defs.h
-11206;0x2bc6;SAFE_MODE_CONTROLLER_FAILURE;HIGH;No description;mission/acs/defs.h
+11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;The limits for the rotation in safe mode were violated.;mission/acs/defs.h
+11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;The system has recovered from a safe rate rotation violation.;mission/acs/defs.h
+11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;Multiple RWs are invalid, uncommandable and therefore higher ACS modes cannot be maintained.;mission/acs/defs.h
+11203;0x2bc3;MEKF_INVALID_INFO;INFO;MEKF was not able to compute a solution. P1: MEKF state on exit;mission/acs/defs.h
+11204;0x2bc4;MEKF_RECOVERY;INFO;MEKF is able to compute a solution again.;mission/acs/defs.h
+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
 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
@@ -101,8 +102,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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
 11403;0x2c8b;HEATER_WENT_OFF;INFO;No description;mission/tcs/HeaterHandler.h
-11404;0x2c8c;SWITCH_ALREADY_ON;LOW;No description;mission/tcs/HeaterHandler.h
-11405;0x2c8d;SWITCH_ALREADY_OFF;LOW;No description;mission/tcs/HeaterHandler.h
+11404;0x2c8c;SWITCH_ALREADY_ON;INFO;No description;mission/tcs/HeaterHandler.h
+11405;0x2c8d;SWITCH_ALREADY_OFF;INFO;No description;mission/tcs/HeaterHandler.h
 11406;0x2c8e;MAIN_SWITCH_TIMEOUT;MEDIUM;No description;mission/tcs/HeaterHandler.h
 11407;0x2c8f;FAULTY_HEATER_WAS_ON;LOW;No description;mission/tcs/HeaterHandler.h
 11500;0x2cec;BURN_PHASE_START;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/SolarArrayDeploymentHandler.h
@@ -145,17 +146,20 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12300;0x300c;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/payload/PlocMemoryDumper.h
 12301;0x300d;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;linux/payload/PlocMemoryDumper.h
 12302;0x300e;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/payload/PlocMemoryDumper.h
-12401;0x3071;INVALID_TC_FRAME;HIGH;No description;linux/ipcore/PdecHandler.h
-12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/PdecHandler.h
-12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/PdecHandler.h
-12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
-12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
-12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
-12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/PdecHandler.h
-12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
-12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
-12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
-12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
+12401;0x3071;INVALID_TC_FRAME;HIGH;No description;linux/ipcore/pdec.h
+12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/pdec.h
+12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/pdec.h
+12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/pdec.h
+12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/pdec.h
+12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/pdec.h
+12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/pdec.h
+12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/pdec.h
+12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/pdec.h
+12410;0x307a;PDEC_TRYING_RESET_WITH_INIT;LOW;Trying a PDEC reset with complete re-initialization;linux/ipcore/pdec.h
+12411;0x307b;PDEC_TRYING_RESET_NO_INIT;LOW;Trying a PDEC reset without re-initialization.;linux/ipcore/pdec.h
+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
 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
@@ -203,11 +207,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/AcsBoardAssembly.h
 12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/AcsBoardAssembly.h
 12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/AcsBoardAssembly.h
+12804;0x3204;DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY;MEDIUM;This is triggered when the assembly would have normally switched the board side, but the GPS device of the other side was marked faulty. P1: Current submode.;mission/system/acs/AcsBoardAssembly.h
 12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;No description;mission/system/acs/SusAssembly.h
 12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/SusAssembly.h
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
-13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/objects/TcsBoardAssembly.h
+13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
 13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
 13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
@@ -250,23 +255,26 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13904;0x3650;WRITE_CONFIGFILE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13905;0x3651;READ_CONFIGFILE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
-14000;0x36b0;ALLOC_FAILURE;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14001;0x36b1;REBOOT_SW;LOW; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
-14002;0x36b2;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h
-14003;0x36b3;REBOOT_HW;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14004;0x36b4;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h
-14005;0x36b5;VERSION_INFO;INFO;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.;bsp_q7s/core/CoreController.h
-14006;0x36b6;CURRENT_IMAGE_INFO;INFO;P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
-14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;bsp_q7s/core/CoreController.h
-14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;bsp_q7s/core/CoreController.h
-14010;0x36ba;I2C_UNAVAILABLE_REBOOT;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/ThermalController.h
-14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/ThermalController.h
-14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14103;0x3717;PLOC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14000;0x36b0;ALLOC_FAILURE;MEDIUM;No description;mission/sysDefs.h
+14001;0x36b1;REBOOT_SW;LOW; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;mission/sysDefs.h
+14002;0x36b2;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;mission/sysDefs.h
+14003;0x36b3;REBOOT_HW;MEDIUM;No description;mission/sysDefs.h
+14004;0x36b4;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;mission/sysDefs.h
+14005;0x36b5;VERSION_INFO;INFO;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
+14006;0x36b6;CURRENT_IMAGE_INFO;INFO;P1: Current Chip, P2: Current Copy;mission/sysDefs.h
+14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;mission/sysDefs.h
+14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;mission/sysDefs.h
+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
+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
+14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14105;0x3719;CAMERA_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+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;MEDIUM;No description;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

generators/bsp_hosted_objects.csv

@@ -30,6 +30,8 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44130046;GPS_0_HEALTH_DEV
+0x44130047;GPS_1_HEALTH_DEV
 0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER

generators/bsp_hosted_returnvalues.csv

@@ -371,8 +371,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_NoPacketFound;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x3f02;DLEE_PossiblePacketLoss;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
 0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
@@ -402,9 +402,12 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
 0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
@@ -440,7 +443,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;167;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x510a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
@@ -496,7 +500,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x6900;ACSCTRL_FileDeletionFailed;No description;0;ACS_CTRL;mission/controller/AcsController.h
+0x6900;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;0;ACS_CTRL;mission/controller/AcsController.h
 0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
@@ -505,9 +509,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6a07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6b01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
-0x6c01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
-0x6d01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
-0x7000;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x7001;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x7100;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6d00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6d01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6e00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h

generators/bsp_q7s_events.csv

@@ -86,13 +86,14 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
-11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;No description;mission/acs/defs.h
-11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;No description;mission/acs/defs.h
-11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;No description;mission/acs/defs.h
-11203;0x2bc3;MEKF_INVALID_INFO;INFO;No description;mission/acs/defs.h
-11204;0x2bc4;MEKF_RECOVERY;INFO;No description;mission/acs/defs.h
-11205;0x2bc5;MEKF_INVALID_MODE_VIOLATION;HIGH;No description;mission/acs/defs.h
-11206;0x2bc6;SAFE_MODE_CONTROLLER_FAILURE;HIGH;No description;mission/acs/defs.h
+11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;The limits for the rotation in safe mode were violated.;mission/acs/defs.h
+11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;The system has recovered from a safe rate rotation violation.;mission/acs/defs.h
+11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;Multiple RWs are invalid, uncommandable and therefore higher ACS modes cannot be maintained.;mission/acs/defs.h
+11203;0x2bc3;MEKF_INVALID_INFO;INFO;MEKF was not able to compute a solution. P1: MEKF state on exit;mission/acs/defs.h
+11204;0x2bc4;MEKF_RECOVERY;INFO;MEKF is able to compute a solution again.;mission/acs/defs.h
+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
 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
@@ -101,8 +102,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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
 11403;0x2c8b;HEATER_WENT_OFF;INFO;No description;mission/tcs/HeaterHandler.h
-11404;0x2c8c;SWITCH_ALREADY_ON;LOW;No description;mission/tcs/HeaterHandler.h
-11405;0x2c8d;SWITCH_ALREADY_OFF;LOW;No description;mission/tcs/HeaterHandler.h
+11404;0x2c8c;SWITCH_ALREADY_ON;INFO;No description;mission/tcs/HeaterHandler.h
+11405;0x2c8d;SWITCH_ALREADY_OFF;INFO;No description;mission/tcs/HeaterHandler.h
 11406;0x2c8e;MAIN_SWITCH_TIMEOUT;MEDIUM;No description;mission/tcs/HeaterHandler.h
 11407;0x2c8f;FAULTY_HEATER_WAS_ON;LOW;No description;mission/tcs/HeaterHandler.h
 11500;0x2cec;BURN_PHASE_START;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/SolarArrayDeploymentHandler.h
@@ -145,17 +146,20 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12300;0x300c;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/payload/PlocMemoryDumper.h
 12301;0x300d;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;linux/payload/PlocMemoryDumper.h
 12302;0x300e;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/payload/PlocMemoryDumper.h
-12401;0x3071;INVALID_TC_FRAME;HIGH;No description;linux/ipcore/PdecHandler.h
-12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/PdecHandler.h
-12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/PdecHandler.h
-12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
-12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
-12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
-12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/PdecHandler.h
-12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/PdecHandler.h
-12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/PdecHandler.h
-12410;0x307a;PDEC_RESET_FAILED;HIGH;Failed to pull PDEC reset to low;linux/ipcore/PdecHandler.h
-12411;0x307b;OPEN_IRQ_FILE_FAILED;HIGH;Failed to open the IRQ uio file;linux/ipcore/PdecHandler.h
+12401;0x3071;INVALID_TC_FRAME;HIGH;No description;linux/ipcore/pdec.h
+12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/pdec.h
+12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/pdec.h
+12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/pdec.h
+12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/pdec.h
+12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/pdec.h
+12407;0x3077;TOO_MANY_IRQS;MEDIUM;Too many IRQs over the time window of one second. P1: Allowed TCs;linux/ipcore/pdec.h
+12408;0x3078;POLL_SYSCALL_ERROR_PDEC;MEDIUM;No description;linux/ipcore/pdec.h
+12409;0x3079;WRITE_SYSCALL_ERROR_PDEC;HIGH;No description;linux/ipcore/pdec.h
+12410;0x307a;PDEC_TRYING_RESET_WITH_INIT;LOW;Trying a PDEC reset with complete re-initialization;linux/ipcore/pdec.h
+12411;0x307b;PDEC_TRYING_RESET_NO_INIT;LOW;Trying a PDEC reset without re-initialization.;linux/ipcore/pdec.h
+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
 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
@@ -203,11 +207,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/AcsBoardAssembly.h
 12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/AcsBoardAssembly.h
 12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/AcsBoardAssembly.h
+12804;0x3204;DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY;MEDIUM;This is triggered when the assembly would have normally switched the board side, but the GPS device of the other side was marked faulty. P1: Current submode.;mission/system/acs/AcsBoardAssembly.h
 12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;No description;mission/system/acs/SusAssembly.h
 12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/SusAssembly.h
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
-13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/objects/TcsBoardAssembly.h
+13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
 13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
 13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
@@ -250,23 +255,26 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13904;0x3650;WRITE_CONFIGFILE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
 13905;0x3651;READ_CONFIGFILE_FAILED;MEDIUM;No description;mission/utility/GlobalConfigHandler.h
-14000;0x36b0;ALLOC_FAILURE;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14001;0x36b1;REBOOT_SW;LOW; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
-14002;0x36b2;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h
-14003;0x36b3;REBOOT_HW;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14004;0x36b4;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h
-14005;0x36b5;VERSION_INFO;INFO;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.;bsp_q7s/core/CoreController.h
-14006;0x36b6;CURRENT_IMAGE_INFO;INFO;P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
-14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;bsp_q7s/core/CoreController.h
-14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;bsp_q7s/core/CoreController.h
-14010;0x36ba;I2C_UNAVAILABLE_REBOOT;MEDIUM;No description;bsp_q7s/core/CoreController.h
-14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/ThermalController.h
-14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/ThermalController.h
-14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14103;0x3717;PLOC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14105;0x3719;HPA_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
-14106;0x371a;PLPCDU_OVERHEATING;HIGH;No description;mission/controller/ThermalController.h
+14000;0x36b0;ALLOC_FAILURE;MEDIUM;No description;mission/sysDefs.h
+14001;0x36b1;REBOOT_SW;LOW; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;mission/sysDefs.h
+14002;0x36b2;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;mission/sysDefs.h
+14003;0x36b3;REBOOT_HW;MEDIUM;No description;mission/sysDefs.h
+14004;0x36b4;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;mission/sysDefs.h
+14005;0x36b5;VERSION_INFO;INFO;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
+14006;0x36b6;CURRENT_IMAGE_INFO;INFO;P1: Current Chip, P2: Current Copy;mission/sysDefs.h
+14007;0x36b7;REBOOT_COUNTER;INFO;Total reboot counter, which is the sum of the boot count of all individual images.;mission/sysDefs.h
+14008;0x36b8;INDIVIDUAL_BOOT_COUNTS;INFO;Get the boot count of the individual images. P1: First 16 bits boot count of image 0 0, last 16 bits boot count of image 0 1. P2: First 16 bits boot count of image 1 0, last 16 bits boot count of image 1 1.;mission/sysDefs.h
+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
+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
+14104;0x3718;OBC_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+14105;0x3719;CAMERA_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
+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;MEDIUM;No description;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

generators/bsp_q7s_objects.csv

@@ -29,6 +29,8 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44130046;GPS_0_HEALTH_DEV
+0x44130047;GPS_1_HEALTH_DEV
 0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER

generators/bsp_q7s_returnvalues.csv

@@ -371,8 +371,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_NoPacketFound;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x3f02;DLEE_PossiblePacketLoss;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
 0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
@@ -402,9 +402,12 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
 0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
@@ -440,7 +443,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;167;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x510a;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
 0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
@@ -492,8 +496,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
 0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
 0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x5900;IPCI_NoReplyAvailable;No description;0;CCSDS_IP_CORE_BRIDGE;linux/acs/ImtqPollingTask.h
-0x5901;IPCI_NoPacketFound;No description;1;CCSDS_IP_CORE_BRIDGE;linux/com/SyrlinksComHandler.h
 0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
 0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
 0x5c01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
@@ -515,21 +517,21 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x5d05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
 0x5ea0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;160;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
 0x5ea1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;161;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
-0x5fa0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa1;PDEC_FrameDirtyRetval;No description;161;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa2;PDEC_FrameIllegalMultipleReasons;No description;162;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa3;PDEC_AdDiscardedLockoutRetval;No description;163;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa4;PDEC_AdDiscardedWaitRetval;No description;164;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa5;PDEC_AdDiscardedNsVs;No description;165;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa6;PDEC_NoReportRetval;No description;166;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa7;PDEC_ErrorVersionNumberRetval;No description;167;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa8;PDEC_IllegalCombinationRetval;No description;168;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fa9;PDEC_InvalidScIdRetval;No description;169;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5faa;PDEC_InvalidVcIdMsbRetval;No description;170;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fab;PDEC_InvalidVcIdLsbRetval;No description;171;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fac;PDEC_NsNotZeroRetval;No description;172;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fae;PDEC_InvalidBcCc;No description;174;PDEC_HANDLER;linux/ipcore/PdecHandler.h
-0x5fb0;PDEC_CommandNotImplemented;Received action message with unknown action id;176;PDEC_HANDLER;linux/ipcore/PdecHandler.h
+0x5fa0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa1;PDEC_FrameDirtyRetval;No description;161;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa2;PDEC_FrameIllegalMultipleReasons;No description;162;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa3;PDEC_AdDiscardedLockoutRetval;No description;163;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa4;PDEC_AdDiscardedWaitRetval;No description;164;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa5;PDEC_AdDiscardedNsVs;No description;165;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa6;PDEC_NoReportRetval;No description;166;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa7;PDEC_ErrorVersionNumberRetval;No description;167;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa8;PDEC_IllegalCombinationRetval;No description;168;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fa9;PDEC_InvalidScIdRetval;No description;169;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5faa;PDEC_InvalidVcIdMsbRetval;No description;170;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fab;PDEC_InvalidVcIdLsbRetval;No description;171;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fac;PDEC_NsNotZeroRetval;No description;172;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fae;PDEC_InvalidBcCc;No description;174;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fb0;PDEC_CommandNotImplemented;Received action message with unknown action id;176;PDEC_HANDLER;linux/ipcore/pdec.h
 0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
 0x61a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;160;RATE_SETTER;linux/ipcore/PtmeConfig.h
 0x61a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);161;RATE_SETTER;linux/ipcore/PtmeConfig.h
@@ -541,7 +543,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
 0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
 0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x6502;PLMPHLP_InvalidCrc;No description;2;PLOC_MPSOC_HELPER;linux/payload/ScexHelper.h
 0x65a0;PLMPHLP_FileClosedAccidentally;File accidentally close;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocHelper.h
 0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
@@ -582,7 +583,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x68b5;SPVRTVIF_SupvHelperExecuting;Supervisor helper task ist currently executing a command (wait until helper tas has finished or interrupt by sending the terminate command);181;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x68c0;SPVRTVIF_BufTooSmall;No description;192;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x68c1;SPVRTVIF_NoReplyTimeout;No description;193;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x6900;ACSCTRL_FileDeletionFailed;No description;0;ACS_CTRL;mission/controller/AcsController.h
+0x6900;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;0;ACS_CTRL;mission/controller/AcsController.h
 0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
@@ -591,21 +592,18 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6a07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6a09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6b01;ACSSAF_SafectrlMekfInputInvalid;No description;1;ACS_SAFE;mission/controller/acs/control/SafeCtrl.h
-0x6c01;ACSPTG_PtgctrlMekfInputInvalid;No description;1;ACS_PTG;mission/controller/acs/control/PtgCtrl.h
-0x6d01;ACSDTB_DetumbleNoSensordata;No description;1;ACS_DETUMBLE;mission/controller/acs/control/Detumble.h
-0x6e00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6e0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6f00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.h
-0x7000;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x7001;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x7100;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
-0x7300;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
+0x6b00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6b0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
+0x6c00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.h
+0x6d00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6d01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
+0x6e00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x7000;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 291 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateEvents.h"
 
@@ -97,6 +97,7 @@ const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 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 *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
@@ -160,8 +161,11 @@ const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
 const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_TRYING_RESET_WITH_INIT_STRING = "PDEC_TRYING_RESET_WITH_INIT";
+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 *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";
@@ -209,6 +213,7 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING = "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
@@ -265,14 +270,17 @@ const char *VERSION_INFO_STRING = "VERSION_INFO";
 const char *CURRENT_IMAGE_INFO_STRING = "CURRENT_IMAGE_INFO";
 const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
-const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
+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 *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";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+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 *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";
@@ -476,8 +484,10 @@ const char *translateEvents(Event event) {
     case (11204):
       return MEKF_RECOVERY_STRING;
     case (11205):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
+    case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
@@ -602,9 +612,15 @@ const char *translateEvents(Event event) {
     case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
     case (12410):
-      return PDEC_RESET_FAILED_STRING;
+      return PDEC_TRYING_RESET_WITH_INIT_STRING;
     case (12411):
+      return PDEC_TRYING_RESET_NO_INIT_STRING;
+    case (12412):
+      return PDEC_RESET_FAILED_STRING;
+    case (12413):
       return OPEN_IRQ_FILE_FAILED_STRING;
+    case (12414):
+      return PDEC_INIT_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -699,6 +715,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):
@@ -812,21 +830,27 @@ const char *translateEvents(Event event) {
     case (14008):
       return INDIVIDUAL_BOOT_COUNTS_STRING;
     case (14010):
-      return I2C_UNAVAILABLE_REBOOT_STRING;
+      return TRYING_I2C_RECOVERY_STRING;
+    case (14011):
+      return I2C_REBOOT_STRING;
+    case (14012):
+      return PDEC_REBOOT_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
+    case (14108):
+      return MGT_OVERHEATING_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 173 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 175 translations.
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -244,6 +246,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

linux/ObjectFactory.cpp

@@ -17,8 +17,8 @@
 #include <mission/payload/ScexDeviceHandler.h>
 #include <mission/system/acs/SusAssembly.h>
 #include <mission/system/acs/SusFdir.h>
-#include <mission/system/fdir/RtdFdir.h>
-#include <mission/system/objects/TcsBoardAssembly.h>
+#include <mission/system/tcs/RtdFdir.h>
+#include <mission/system/tcs/TcsBoardAssembly.h>
 #include <mission/tcs/Max31865EiveHandler.h>
 
 #include "OBSWConfig.h"
@@ -27,8 +27,9 @@
 #include "devices/gpioIds.h"
 #include "eive/definitions.h"
 #include "mission/system/acs/acsModeTree.h"
+#include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
-#include "mission/system/tree/tcsModeTree.h"
+#include "mission/tcs/defs.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
                                               PowerSwitchIF& pwrSwitcher, std::string spiDev,
@@ -278,7 +279,8 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
   std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
   RtdFdir* rtdFdir = nullptr;
 
-  TcsBoardAssembly* tcsBoardAss = ObjectFactory::createTcsBoardAssy(*pwrSwitcher);
+  TcsBoardAssembly* tcsBoardAss =
+      ObjectFactory::createTcsBoardAssy(*pwrSwitcher, tcs::TCS_BOARD_SHORTLY_UNAVAILABLE);
 
   // Create special low level reader communication interface
   new Max31865RtdPolling(objects::SPI_RTD_COM_IF, comIF, gpioComIF);

linux/acs/AcsBoardPolling.cpp

@@ -113,7 +113,8 @@ ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* send
     if (req->mode != adis.mode) {
       if (req->mode == acs::SimpleSensorMode::NORMAL) {
         adis.type = req->type;
-        adis.countdown.setTimeout(adis1650x::START_UP_TIME);
+        // The initial countdown is handled by the device handler now.
+        // adis.countdown.setTimeout(adis1650x::START_UP_TIME);
         if (adis.type == adis1650x::Type::ADIS16507) {
           adis.ownReply.data.accelScaling = adis1650x::ACCELEROMETER_RANGE_16507;
         } else if (adis.type == adis1650x::Type::ADIS16505) {
@@ -121,11 +122,13 @@ ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* send
         } else {
           sif::warning << "AcsBoardPolling: Unknown ADIS type" << std::endl;
         }
+        adis.replyResult = returnvalue::FAILED;
         adis.performStartup = true;
       } else if (req->mode == acs::SimpleSensorMode::OFF) {
         adis.performStartup = false;
         adis.ownReply.cfgWasSet = false;
         adis.ownReply.dataWasSet = false;
+        adis.replyResult = returnvalue::OK;
       }
       adis.mode = req->mode;
     }
@@ -142,8 +145,10 @@ ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* send
       if (req->mode == acs::SimpleSensorMode::NORMAL) {
         std::memcpy(gyro.sensorCfg, req->ctrlRegs, 5);
         gyro.performStartup = true;
+        gyro.replyResult = returnvalue::FAILED;
       } else {
         gyro.ownReply.cfgWasSet = false;
+        gyro.replyResult = returnvalue::OK;
       }
       gyro.mode = req->mode;
     }
@@ -159,8 +164,10 @@ ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* send
     if (req->mode != mgm.mode) {
       if (req->mode == acs::SimpleSensorMode::NORMAL) {
         mgm.performStartup = true;
+        mgm.replyResult = returnvalue::FAILED;
       } else {
         mgm.ownReply.dataWasSet = false;
+        mgm.replyResult = returnvalue::OK;
         mgm.ownReply.temperatureWasSet = false;
       }
       mgm.mode = req->mode;
@@ -177,8 +184,10 @@ ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* send
     if (req->mode != mgm.mode) {
       if (req->mode == acs::SimpleSensorMode::NORMAL) {
         mgm.performStartup = true;
+        mgm.replyResult = returnvalue::FAILED;
       } else {
         mgm.ownReply.dataWasRead = false;
+        mgm.replyResult = returnvalue::OK;
       }
       mgm.mode = req->mode;
     }
@@ -309,18 +318,18 @@ void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
       std::memcpy(cmdBuf.data() + 1, l3g.sensorCfg, 5);
       result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
       if (result != returnvalue::OK) {
-        l3g.replyResult = returnvalue::OK;
+        l3g.replyResult = result;
       }
       // Ignore useless reply and red config
       cmdBuf[0] = l3gd20h::CTRL_REG_1 | l3gd20h::AUTO_INCREMENT_MASK | l3gd20h::READ_MASK;
       std::memset(cmdBuf.data() + 1, 0, 5);
       result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
       if (result != returnvalue::OK) {
-        l3g.replyResult = returnvalue::OK;
+        l3g.replyResult = result;
       }
       result = spiComIF.readReceivedMessage(l3g.cookie, &rawReply, &dummy);
       if (result != returnvalue::OK) {
-        l3g.replyResult = returnvalue::OK;
+        l3g.replyResult = result;
       }
       MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
       // Cross check configuration as verification that communication is working
@@ -331,6 +340,7 @@ void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
           return;
         }
       }
+      l3g.replyResult = returnvalue::OK;
       l3g.performStartup = false;
       l3g.ownReply.cfgWasSet = true;
       l3g.ownReply.sensitivity = l3gd20h::ctrlReg4ToSensitivity(l3g.sensorCfg[3]);
@@ -357,6 +367,7 @@ void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
         return;
       }
     }
+    l3g.replyResult = returnvalue::OK;
     l3g.ownReply.statusReg = rawReply[l3gd20h::STATUS_IDX];
     l3g.ownReply.angVelocities[0] = (rawReply[l3gd20h::OUT_X_H] << 8) | rawReply[l3gd20h::OUT_X_L];
     l3g.ownReply.angVelocities[1] = (rawReply[l3gd20h::OUT_Y_H] << 8) | rawReply[l3gd20h::OUT_Y_L];
@@ -373,7 +384,7 @@ ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen
   std::string device = spiComIF.getSpiDev();
   UnixFileGuard fileHelper(device, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
   if (fileHelper.getOpenResult() != returnvalue::OK) {
-    return SpiComIF::OPENING_FILE_FAILED;
+    return spi::OPENING_FILE_FAILED;
   }
   spi::SpiModes spiMode = spi::SpiModes::MODE_0;
   uint32_t spiSpeed = 0;
@@ -416,7 +427,7 @@ ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen
     retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), cookie.getTransferStructHandle());
     if (retval < 0) {
       utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
-      result = SpiComIF::FULL_DUPLEX_TRANSFER_FAILED;
+      result = spi::FULL_DUPLEX_TRANSFER_FAILED;
     }
 #if FSFW_HAL_SPI_WIRETAPPING == 1
     comIf->performSpiWiretapping(cookie);
@@ -443,20 +454,15 @@ ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen
 void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
   ReturnValue_t result;
   acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
-  bool cdHasTimedOut = false;
   bool mustPerformStartup = false;
   {
     MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
     mode = gyro.mode;
-    cdHasTimedOut = gyro.countdown.hasTimedOut();
     mustPerformStartup = gyro.performStartup;
   }
   if (mode == acs::SimpleSensorMode::OFF) {
     return;
   }
-  if (not cdHasTimedOut) {
-    return;
-  }
   if (mustPerformStartup) {
     uint8_t regList[6];
     // Read configuration
@@ -495,6 +501,7 @@ void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
     gyro.ownReply.cfg.prodId = prodId;
     gyro.ownReply.data.sensitivity = adis1650x::rangMdlToSensitivity(gyro.ownReply.cfg.rangMdl);
     gyro.performStartup = false;
+    gyro.replyResult = returnvalue::OK;
   }
   // Read regular registers
   std::memcpy(cmdBuf.data(), adis1650x::BURST_READ_ENABLE.data(),
@@ -533,6 +540,7 @@ void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
   }
 
   MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+  gyro.replyResult = returnvalue::OK;
   gyro.ownReply.dataWasSet = true;
   gyro.ownReply.cfg.diagStat = rawReply[2] << 8 | rawReply[3];
   gyro.ownReply.data.angVelocities[0] = (rawReply[4] << 8) | rawReply[5];
@@ -590,6 +598,7 @@ void AcsBoardPolling::mgmLis3Handler(MgmLis3& mgm) {
       }
       // Done here. We can always read back config and data during periodic handling
       mgm.performStartup = false;
+      mgm.replyResult = returnvalue::OK;
     }
     cmdBuf[0] = mgmLis3::readCommand(mgmLis3::CTRL_REG1, true);
     std::memset(cmdBuf.data() + 1, 0, mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS);
@@ -607,7 +616,7 @@ void AcsBoardPolling::mgmLis3Handler(MgmLis3& mgm) {
     // Verify communication by re-checking config
     if (rawReply[1] != mgm.cfg[0] or rawReply[2] != mgm.cfg[1] or rawReply[3] != mgm.cfg[2] or
         rawReply[4] != mgm.cfg[3] or rawReply[5] != mgm.cfg[4]) {
-      mgm.replyResult = result;
+      mgm.replyResult = returnvalue::FAILED;
       return;
     }
     {
@@ -634,6 +643,7 @@ void AcsBoardPolling::mgmLis3Handler(MgmLis3& mgm) {
       return;
     }
     MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mgm.replyResult = returnvalue::OK;
     mgm.ownReply.temperatureWasSet = true;
     mgm.ownReply.temperatureRaw = (rawReply[2] << 8) | rawReply[1];
   }
@@ -704,6 +714,7 @@ void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
         return;
       }
       mgm.performStartup = false;
+      mgm.replyResult = returnvalue::OK;
     }
     // Regular read operation
     cmdBuf[0] = mgmRm3100::MEASUREMENT_REG_START | mgmRm3100::READ_MASK;
@@ -725,6 +736,7 @@ void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
       mgm.ownReply.scaleFactors[idx] = 1.0 / mgmRm3100::DEFAULT_GAIN;
     }
     mgm.ownReply.dataWasRead = true;
+    mgm.replyResult = returnvalue::OK;
     // Bitshift trickery to account for 24 bit signed value.
     mgm.ownReply.mgmValuesRaw[0] =
         ((rawReply[1] << 24) | (rawReply[2] << 16) | (rawReply[3] << 8)) >> 8;

linux/acs/CMakeLists.txt

@@ -1,6 +1,10 @@
-target_sources(
-  ${OBSW_NAME} PUBLIC AcsBoardPolling.cpp ImtqPollingTask.cpp RwPollingTask.cpp
-                      SusPolling.cpp StrComHandler.cpp)
+target_sources(${OBSW_NAME} PUBLIC AcsBoardPolling.cpp ImtqPollingTask.cpp
+                                   RwPollingTask.cpp SusPolling.cpp)
+
+# Dependency on proprietary library
+if(TGT_BSP MATCHES "arm/q7s")
+  target_sources(${OBSW_NAME} PUBLIC StrComHandler.cpp)
+endif()
 
 if(EIVE_BUILD_GPSD_GPS_HANDLER)
   target_sources(${OBSW_NAME} PRIVATE GpsHyperionLinuxController.cpp)

linux/acs/GpsHyperionLinuxController.cpp

@@ -18,8 +18,11 @@
 #include <ctime>
 
 GpsHyperionLinuxController::GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
-                                                       bool debugHyperionGps)
-    : ExtendedControllerBase(objectId), gpsSet(this), debugHyperionGps(debugHyperionGps) {}
+                                                       bool enableHkSets, bool debugHyperionGps)
+    : ExtendedControllerBase(objectId),
+      gpsSet(this),
+      enableHkSets(enableHkSets),
+      debugHyperionGps(debugHyperionGps) {}
 
 GpsHyperionLinuxController::~GpsHyperionLinuxController() {
   gps_stream(&gps, WATCH_DISABLE, nullptr);
@@ -86,7 +89,7 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
   localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
-  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), false, 30.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
   return returnvalue::OK;
 }
 
@@ -99,6 +102,7 @@ void GpsHyperionLinuxController::setResetPinTriggerFunction(gpioResetFunction_t
 ReturnValue_t GpsHyperionLinuxController::performOperation(uint8_t opCode) {
   handleQueue();
   poolManager.performHkOperation();
+
   while (true) {
 #if OBSW_THREAD_TRACING == 1
     trace::threadTrace(opCounter, "GPS CTRL");

linux/acs/GpsHyperionLinuxController.h

@@ -29,7 +29,7 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
 
   enum ReadModes { SHM = 0, SOCKET = 1 };
 
-  GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId,
+  GpsHyperionLinuxController(object_id_t objectId, object_id_t parentId, bool enableHkSets,
                              bool debugHyperionGps = false);
   virtual ~GpsHyperionLinuxController();
 
@@ -58,6 +58,7 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
  private:
   GpsPrimaryDataset gpsSet;
   gps_data_t gps = {};
+  bool enableHkSets = false;
   const char* currentClientBuf = nullptr;
   ReadModes readMode = ReadModes::SOCKET;
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);

linux/acs/ImtqPollingTask.cpp

@@ -27,7 +27,7 @@ ReturnValue_t ImtqPollingTask::performOperation(uint8_t operationCode) {
 
     comStatus = returnvalue::OK;
     // Stopwatch watch;
-    switch (currentRequest) {
+    switch (currentRequest.requestType) {
       case imtq::RequestType::MEASURE_NO_ACTUATION: {
         // Measured to take 24 ms for debug and release builds.
         // Stopwatch watch;
@@ -51,6 +51,30 @@ void ImtqPollingTask::handleMeasureStep() {
   uint8_t* replyPtr;
   ImtqRepliesDefault replies(replyBuf.data());
   // If some startup handling is added later, set configured after it was done once.
+  if (performStartup) {
+    // Set integration time for the MGM.
+    cmdBuf[0] = imtq::CC::SET_PARAM;
+    size_t dummy = 0;
+    SerializeAdapter::serialize(&imtq::param::INTEGRATION_TIME_SELECT, cmdBuf.data() + 1, &dummy,
+                                cmdBuf.size(), SerializeIF::Endianness::LITTLE);
+    cmdBuf[3] = currentRequest.integrationTimeSel;
+    cmdLen = 4;
+    ReturnValue_t result = performI2cFullRequest(replyBuf.data(), 5);
+    if (result != returnvalue::OK) {
+      comStatus = imtq::STARTUP_CFG_ERROR;
+    }
+    if (replyBuf[0] != imtq::CC::SET_PARAM) {
+      sif::error << "ImtqPollingTask: First byte of reply not equal to sent CC" << std::endl;
+      comStatus = imtq::STARTUP_CFG_ERROR;
+    }
+    if (replyBuf[4] != currentRequest.integrationTimeSel) {
+      sif::error << "ImtqPollingTask: Integration time configuration failed" << std::endl;
+      comStatus = imtq::STARTUP_CFG_ERROR;
+    }
+    currentIntegrationTimeMs =
+        imtq::integrationTimeFromSelectValue(currentRequest.integrationTimeSel);
+    performStartup = false;
+  }
   replies.setConfigured();
 
   // Can be used later to verify correct timing (e.g. all data has been read)
@@ -73,7 +97,7 @@ void ImtqPollingTask::handleMeasureStep() {
     return;
   }
 
-  if (specialRequest != imtq::SpecialRequest::NONE) {
+  if (currentRequest.specialRequest != imtq::SpecialRequest::NONE) {
     auto executeSelfTest = [&](imtq::selfTest::Axis axis) {
       cmdBuf[0] = imtq::CC::SELF_TEST_CMD;
       cmdBuf[1] = axis;
@@ -81,7 +105,7 @@ void ImtqPollingTask::handleMeasureStep() {
     };
     // If a self-test is already ongoing, ignore the request.
     if (replies.getSystemState()[2] != static_cast<uint8_t>(imtq::mode::SELF_TEST)) {
-      switch (specialRequest) {
+      switch (currentRequest.specialRequest) {
         case (imtq::SpecialRequest::DO_SELF_TEST_POS_X): {
           executeSelfTest(imtq::selfTest::Axis::X_POSITIVE);
           break;
@@ -234,18 +258,21 @@ ReturnValue_t ImtqPollingTask::initializeInterface(CookieIF* cookie) {
 ReturnValue_t ImtqPollingTask::sendMessage(CookieIF* cookie, const uint8_t* sendData,
                                            size_t sendLen) {
   const auto* imtqReq = reinterpret_cast<const imtq::Request*>(sendData);
+  if (sendLen != sizeof(imtq::Request)) {
+    return returnvalue::FAILED;
+  }
   {
     MutexGuard mg(ipcLock);
-    if (imtqReq->request == imtq::RequestType::ACTUATE) {
-      std::memcpy(dipoles, imtqReq->dipoles, sizeof(dipoles));
-      torqueDuration = imtqReq->torqueDuration;
-    }
-    currentRequest = imtqReq->request;
-    specialRequest = imtqReq->specialRequest;
     if (state != InternalState::IDLE) {
       return returnvalue::FAILED;
     }
     state = InternalState::IS_BUSY;
+    if (currentRequest.mode != imtqReq->mode) {
+      if (imtqReq->mode == acs::SimpleSensorMode::NORMAL) {
+        performStartup = true;
+      }
+    }
+    std::memcpy(&currentRequest, imtqReq, sendLen);
   }
   semaphore->release();
 
@@ -345,10 +372,10 @@ void ImtqPollingTask::buildDipoleCommand() {
   uint8_t* serPtr = cmdBuf.data() + 1;
   size_t serLen = 0;
   for (uint8_t idx = 0; idx < 3; idx++) {
-    SerializeAdapter::serialize(&dipoles[idx], &serPtr, &serLen, cmdBuf.size(),
+    SerializeAdapter::serialize(&currentRequest.dipoles[idx], &serPtr, &serLen, cmdBuf.size(),
                                 SerializeIF::Endianness::LITTLE);
   }
-  SerializeAdapter::serialize(&torqueDuration, &serPtr, &serLen, cmdBuf.size(),
+  SerializeAdapter::serialize(&currentRequest.torqueDuration, &serPtr, &serLen, cmdBuf.size(),
                               SerializeIF::Endianness::LITTLE);
   // sif::debug << "Dipole X: " << dipoles[0] << std::endl;
   // sif::debug << "Torqeu Dur: " << torqueDuration << std::endl;
@@ -357,22 +384,28 @@ void ImtqPollingTask::buildDipoleCommand() {
 
 ReturnValue_t ImtqPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
                                                    size_t* size) {
-  imtq::RequestType currentRequest;
+  imtq::Request currentRequest;
   {
     MutexGuard mg(ipcLock);
-    currentRequest = this->currentRequest;
+    std::memcpy(&currentRequest, &this->currentRequest, sizeof(currentRequest));
   }
 
   size_t replyLen = 0;
-  MutexGuard mg(bufLock);
-  if (currentRequest == imtq::RequestType::MEASURE_NO_ACTUATION) {
-    replyLen = getExchangeBufLen(specialRequest);
-    memcpy(exchangeBuf.data(), replyBuf.data(), replyLen);
-  } else if (currentRequest == imtq::RequestType::ACTUATE) {
-    replyLen = ImtqRepliesWithTorque::BASE_LEN;
-    memcpy(exchangeBuf.data(), replyBufActuation.data(), replyLen);
-  } else {
-    *size = 0;
+  {
+    MutexGuard mg(bufLock);
+    if (currentRequest.requestType == imtq::RequestType::MEASURE_NO_ACTUATION) {
+      replyLen = getExchangeBufLen(currentRequest.specialRequest);
+      memcpy(exchangeBuf.data(), replyBuf.data(), replyLen);
+    } else if (currentRequest.requestType == imtq::RequestType::ACTUATE) {
+      replyLen = ImtqRepliesWithTorque::BASE_LEN;
+      memcpy(exchangeBuf.data(), replyBufActuation.data(), replyLen);
+    } else {
+      *size = 0;
+    }
+  }
+  {
+    MutexGuard mg(ipcLock);
+    this->currentRequest.requestType = imtq::RequestType::DO_NOTHING;
   }
   *buffer = exchangeBuf.data();
   *size = replyLen;
@@ -417,6 +450,7 @@ void ImtqPollingTask::clearReadFlagsWithTorque(ImtqRepliesWithTorque& replies) {
 ReturnValue_t ImtqPollingTask::performI2cFullRequest(uint8_t* reply, size_t replyLen) {
   int fd = 0;
   if (cmdLen == 0 or reply == nullptr) {
+    sif::error << "ImtqPollingTask: Command lenght is zero or reply PTR is invalid" << std::endl;
     return returnvalue::FAILED;
   }
 

linux/acs/ImtqPollingTask.h

@@ -3,6 +3,7 @@
 
 #include <fsfw/tasks/SemaphoreIF.h>
 #include <fsfw_hal/linux/i2c/I2cCookie.h>
+#include <mission/acs/acsBoardPolling.h>
 
 #include <atomic>
 
@@ -21,10 +22,10 @@ class ImtqPollingTask : public SystemObject,
   ReturnValue_t initialize() override;
 
  private:
+  //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t NO_REPLY_AVAILABLE = returnvalue::makeCode(2, 0);
 
   enum class InternalState { IDLE, IS_BUSY } state = InternalState::IDLE;
-  imtq::RequestType currentRequest = imtq::RequestType::MEASURE_NO_ACTUATION;
 
   SemaphoreIF* semaphore;
   ReturnValue_t comStatus = returnvalue::OK;
@@ -38,10 +39,9 @@ class ImtqPollingTask : public SystemObject,
   // Required in addition to integration time, otherwise old data might be read.
   static constexpr uint32_t MGM_READ_BUFFER_TIME_MS = 6;
   bool ignoreNextActuateRequest = false;
+  bool performStartup = false;
 
-  imtq::SpecialRequest specialRequest = imtq::SpecialRequest::NONE;
-  int16_t dipoles[3] = {};
-  uint16_t torqueDuration = 0;
+  imtq::Request currentRequest{};
 
   std::array<uint8_t, 32> cmdBuf;
   std::array<uint8_t, 524> replyBuf;

linux/acs/RwPollingTask.cpp

@@ -11,6 +11,7 @@
 #include <unistd.h>
 
 #include "devConf.h"
+#include "mission/acs/defs.h"
 #include "mission/acs/rwHelpers.h"
 
 RwPollingTask::RwPollingTask(object_id_t objectId, const char* spiDev, GpioIF& gpioIF)
@@ -35,6 +36,7 @@ ReturnValue_t RwPollingTask::performOperation(uint8_t operationCode) {
     semaphore->acquire();
     // This loop takes 50 ms on a debug build.
     // Stopwatch watch;
+    // Give all device handlers some time to submit requests.
     TaskFactory::delayTask(5);
     int fd = 0;
     for (auto& skip : skipCommandingForRw) {
@@ -45,13 +47,24 @@ ReturnValue_t RwPollingTask::performOperation(uint8_t operationCode) {
     if (result != returnvalue::OK) {
       continue;
     }
+    acs::SimpleSensorMode currentMode;
+    rws::SpecialRwRequest specialRequest;
+
     for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
-      if (rwCookies[idx]->specialRequest == rws::SpecialRwRequest::RESET_MCU) {
+      {
+        MutexGuard mg(ipcLock);
+        currentMode = rwRequests[idx].mode;
+        specialRequest = rwRequests[idx].specialRequest;
+        skipSetSpeedReply[idx] = rwRequests[idx].setSpeed;
+      }
+      if (currentMode == acs::SimpleSensorMode::OFF) {
+        skipCommandingForRw[idx] = true;
+      } else if (specialRequest == rws::SpecialRwRequest::RESET_MCU) {
         prepareSimpleCommand(rws::RESET_MCU);
         // No point in commanding that specific RW for the cycle.
         skipCommandingForRw[idx] = true;
         writeOneRwCmd(idx, fd);
-      } else if (rwCookies[idx]->setSpeed) {
+      } else if (skipSetSpeedReply[idx]) {
         prepareSetSpeedCmd(idx);
         if (writeOneRwCmd(idx, fd) != returnvalue::OK) {
           continue;
@@ -121,31 +134,14 @@ ReturnValue_t RwPollingTask::initializeInterface(CookieIF* cookie) {
 
 ReturnValue_t RwPollingTask::sendMessage(CookieIF* cookie, const uint8_t* sendData,
                                          size_t sendLen) {
-  if (sendData == nullptr or sendLen < 8) {
+  if (sendData == nullptr or sendLen != sizeof(rws::RwRequest)) {
     return DeviceHandlerIF::INVALID_DATA;
   }
-  int32_t speed = 0;
-  uint16_t rampTime = 0;
-  const uint8_t* currentBuf = sendData;
-  bool setSpeed = currentBuf[0];
-  currentBuf += 1;
-  sendLen -= 1;
-  SerializeAdapter::deSerialize(&speed, &currentBuf, &sendLen, SerializeIF::Endianness::MACHINE);
-  SerializeAdapter::deSerialize(&rampTime, &currentBuf, &sendLen, SerializeIF::Endianness::MACHINE);
-  rws::SpecialRwRequest specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
-  if (sendLen == 8 and sendData[7] < static_cast<uint8_t>(rws::SpecialRwRequest::NUM_REQUESTS)) {
-    specialRequest = static_cast<rws::SpecialRwRequest>(sendData[7]);
-  }
-  RwCookie* rwCookie = dynamic_cast<RwCookie*>(cookie);
-  if (rwCookie == nullptr) {
-    return returnvalue::FAILED;
-  }
+  const rws::RwRequest* rwRequest = reinterpret_cast<const rws::RwRequest*>(sendData);
+  uint8_t rwIdx = rwRequest->rwIdx;
   {
     MutexGuard mg(ipcLock);
-    rwCookie->setSpeed = setSpeed;
-    rwCookie->currentRwSpeed = speed;
-    rwCookie->currentRampTime = rampTime;
-    rwCookie->specialRequest = specialRequest;
+    std::memcpy(&rwRequests[rwIdx], rwRequest, sizeof(rws::RwRequest));
     if (state == InternalState::IDLE) {
       state = InternalState::IS_BUSY;
       semaphore->release();
@@ -202,7 +198,7 @@ ReturnValue_t RwPollingTask::openSpi(int flags, int& fd) {
   fd = open(spiDev, flags);
   if (fd < 0) {
     sif::error << "RwPollingTask::openSpi: Failed to open device file" << std::endl;
-    return SpiComIF::OPENING_FILE_FAILED;
+    return spi::OPENING_FILE_FAILED;
   }
 
   return returnvalue::OK;
@@ -332,7 +328,7 @@ ReturnValue_t RwPollingTask::writeOneRwCmd(uint8_t rwIdx, int fd) {
 ReturnValue_t RwPollingTask::readAllRws(DeviceCommandId_t id) {
   // SPI dev will be opened in readNextReply on demand.
   for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
-    if (((id == rws::SET_SPEED) and !rwCookies[idx]->setSpeed) or skipCommandingForRw[idx]) {
+    if (((id == rws::SET_SPEED) and !skipSetSpeedReply[idx]) or skipCommandingForRw[idx]) {
       continue;
     }
     uint8_t* replyBuf;
@@ -395,7 +391,7 @@ void RwPollingTask::fillSpecialRequestArray() {
       specialRequestIds[idx] = DeviceHandlerIF::NO_COMMAND_ID;
       continue;
     }
-    switch (rwCookies[idx]->specialRequest) {
+    switch (rwRequests[idx].specialRequest) {
       case (rws::SpecialRwRequest::GET_TM): {
         specialRequestIds[idx] = rws::GET_TM;
         break;
@@ -426,14 +422,14 @@ void RwPollingTask::handleSpecialRequests() {
     writeOneRwCmd(idx, fd);
   }
   closeSpi(fd);
-  usleep(rws::SPI_REPLY_DELAY);
   for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
     if (specialRequestIds[idx] == DeviceHandlerIF::NO_COMMAND_ID) {
       continue;
     }
     uint8_t* replyBuf;
     size_t maxReadLen = idAndIdxToReadBuffer(specialRequestIds[idx], idx, &replyBuf);
-    result = readNextReply(*rwCookies[idx], replyBuf, maxReadLen);
+    // Skip first byte for actual read buffer: Valid byte
+    result = readNextReply(*rwCookies[idx], replyBuf + 1, maxReadLen);
     if (result == returnvalue::OK) {
       // The first byte is always a flag which shows whether the value was read
       // properly at least once.
@@ -455,17 +451,12 @@ void RwPollingTask::setAllReadFlagsFalse() {
   }
 }
 
-// This closes the SPI
-void RwPollingTask::closeSpi(int fd) {
-  // This will perform the function to close the SPI
-  close(fd);
-  // The SPI is now closed.
-}
+void RwPollingTask::closeSpi(int fd) { close(fd); }
 
 ReturnValue_t RwPollingTask::sendOneMessage(int fd, RwCookie& rwCookie) {
   gpioId_t gpioId = rwCookie.getChipSelectPin();
   if (spiLock == nullptr) {
-    sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
+    sif::warning << "RwPollingTask: Mutex or GPIO interface invalid" << std::endl;
     return returnvalue::FAILED;
   }
   // Add datalinklayer like specified in the datasheet.
@@ -473,7 +464,7 @@ ReturnValue_t RwPollingTask::sendOneMessage(int fd, RwCookie& rwCookie) {
   rws::encodeHdlc(writeBuffer.data(), writeLen, encodedBuffer.data(), lenToSend);
   pullCsLow(gpioId, gpioIF);
   if (write(fd, encodedBuffer.data(), lenToSend) != static_cast<ssize_t>(lenToSend)) {
-    sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
+    sif::error << "RwPollingTask: Write failed!" << std::endl;
     pullCsHigh(gpioId, gpioIF);
     return rws::SPI_WRITE_FAILURE;
   }
@@ -484,7 +475,7 @@ ReturnValue_t RwPollingTask::sendOneMessage(int fd, RwCookie& rwCookie) {
 ReturnValue_t RwPollingTask::pullCsLow(gpioId_t gpioId, GpioIF& gpioIF) {
   ReturnValue_t result = spiLock->lockMutex(TIMEOUT_TYPE, TIMEOUT_MS);
   if (result != returnvalue::OK) {
-    sif::debug << "RwPollingTask::pullCsLow: Failed to lock mutex" << std::endl;
+    sif::warning << "RwPollingTask::pullCsLow: Failed to lock mutex" << std::endl;
     return result;
   }
   // Pull SPI CS low. For now, no support for active high given
@@ -525,8 +516,8 @@ ReturnValue_t RwPollingTask::prepareSetSpeedCmd(uint8_t rwIdx) {
   uint16_t rampTimeToSet = 10;
   {
     MutexGuard mg(ipcLock);
-    speedToSet = rwCookies[rwIdx]->currentRwSpeed;
-    rampTimeToSet = rwCookies[rwIdx]->currentRampTime;
+    speedToSet = rwRequests[rwIdx].currentRwSpeed;
+    rampTimeToSet = rwRequests[rwIdx].currentRampTime;
   }
   size_t serLen = 1;
   SerializeAdapter::serialize(&speedToSet, &serPtr, &serLen, writeBuffer.size(),

linux/acs/RwPollingTask.h

@@ -8,6 +8,7 @@
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <mission/acs/defs.h>
 
 #include "mission/acs/rwHelpers.h"
 
@@ -26,10 +27,6 @@ class RwCookie : public SpiCookie {
   std::array<uint8_t, REPLY_BUF_LEN> replyBuf{};
   std::array<uint8_t, REPLY_BUF_LEN> exchangeBuf{};
   MutexIF* bufLock;
-  bool setSpeed = true;
-  int32_t currentRwSpeed = 0;
-  uint16_t currentRampTime = 0;
-  rws::SpecialRwRequest specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
   uint8_t rwIdx;
 };
 
@@ -50,8 +47,10 @@ class RwPollingTask : public SystemObject, public ExecutableObjectIF, public Dev
   const char* spiDev;
   GpioIF& gpioIF;
   std::array<bool, 4> skipCommandingForRw;
+  std::array<bool, 4> skipSetSpeedReply;
   std::array<DeviceCommandId_t, 4> specialRequestIds;
   std::array<RwCookie*, 4> rwCookies;
+  std::array<rws::RwRequest, 4> rwRequests{};
   std::array<uint8_t, rws::MAX_CMD_SIZE> writeBuffer;
   std::array<uint8_t, rws::MAX_CMD_SIZE * 2> encodedBuffer;
 

linux/acs/StrComHandler.cpp

@@ -17,6 +17,10 @@
 #include "mission/utility/ProgressPrinter.h"
 #include "mission/utility/Timestamp.h"
 
+extern "C" {
+#include <sagitta/client/actionreq.h>
+}
+
 using namespace returnvalue;
 
 StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
@@ -42,7 +46,6 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
   while (true) {
     lock->lockMutex();
     state = InternalState::SLEEPING;
-    datalinkLayer.reset();
     lock->unlockMutex();
     semaphore.acquire();
     switch (state) {
@@ -58,6 +61,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
       }
       case InternalState::UPLOAD_IMAGE: {
         replyTimeout.setTimeout(200);
+        resetReplyHandlingState();
         result = performImageUpload();
         if (result == returnvalue::OK) {
           triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
@@ -68,6 +72,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
       }
       case InternalState::DOWNLOAD_IMAGE: {
         replyTimeout.setTimeout(200);
+        resetReplyHandlingState();
         result = performImageDownload();
         if (result == returnvalue::OK) {
           triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
@@ -78,6 +83,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
       }
       case InternalState::FLASH_READ: {
         replyTimeout.setTimeout(200);
+        resetReplyHandlingState();
         result = performFlashRead();
         if (result == returnvalue::OK) {
           triggerEvent(FLASH_READ_SUCCESSFUL);
@@ -87,7 +93,8 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
         break;
       }
       case InternalState::FIRMWARE_UPDATE: {
-        replyTimeout.setTimeout(200);
+        replyTimeout.setTimeout(2000);
+        resetReplyHandlingState();
         result = performFirmwareUpdate();
         if (result == returnvalue::OK) {
           triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL);
@@ -122,6 +129,7 @@ ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
   }
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::UPLOAD_IMAGE;
   }
   semaphore.release();
@@ -148,6 +156,7 @@ ReturnValue_t StrComHandler::startImageDownload(std::string path) {
   downloadImage.path = path;
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::DOWNLOAD_IMAGE;
   }
   terminate = false;
@@ -184,6 +193,7 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
   flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::FIRMWARE_UPDATE;
   }
   semaphore.release();
@@ -213,6 +223,7 @@ ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegio
   flashRead.size = length;
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::FLASH_READ;
   }
   semaphore.release();
@@ -298,6 +309,7 @@ ReturnValue_t StrComHandler::performImageUpload() {
   uint32_t imageSize = 0;
   struct UploadActionRequest uploadReq;
   uploadReq.position = 0;
+  size_t writtenBytes = 0;
 #ifdef XIPHOS_Q7S
   if (not sdcMan->getActiveSdCard()) {
     return HasFileSystemIF::FILESYSTEM_INACTIVE;
@@ -320,7 +332,9 @@ ReturnValue_t StrComHandler::performImageUpload() {
 #if OBSW_DEBUG_STARTRACKER == 1
   ProgressPrinter progressPrinter("Image upload", imageSize);
 #endif /* OBSW_DEBUG_STARTRACKER == 1 */
-  while ((uploadReq.position + 1) * SIZE_IMAGE_PART < imageSize) {
+  size_t fullChunks = imageSize / SIZE_IMAGE_PART;
+  size_t remainder = imageSize % SIZE_IMAGE_PART;
+  for (size_t idx = 0; idx < fullChunks; idx++) {
     if (terminate) {
       return returnvalue::OK;
     }
@@ -339,6 +353,7 @@ ReturnValue_t StrComHandler::performImageUpload() {
     progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
 #endif /* OBSW_DEBUG_STARTRACKER == 1 */
     uploadReq.position++;
+    writtenBytes += SIZE_IMAGE_PART;
 
     // This does a bit of delaying roughly every second
     if (uploadReq.position % 50 == 0) {
@@ -346,20 +361,20 @@ ReturnValue_t StrComHandler::performImageUpload() {
       TaskFactory::delayTask(2);
     }
   }
-  std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
-  uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART;
-  file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
-  file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
-  file.close();
-  uploadReq.position++;
-  arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
-  result = sendAndRead(size, uploadReq.position);
-  if (result != returnvalue::OK) {
-    return returnvalue::FAILED;
-  }
-  result = checkActionReply(replyLen);
-  if (result != returnvalue::OK) {
-    return result;
+  if (remainder > 0) {
+    std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
+    file.seekg(fullChunks * SIZE_IMAGE_PART, file.beg);
+    file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
+    file.close();
+    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    result = sendAndRead(size, uploadReq.position);
+    if (result != returnvalue::OK) {
+      return returnvalue::FAILED;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
   }
 #if OBSW_DEBUG_STARTRACKER == 1
   progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
@@ -387,7 +402,8 @@ ReturnValue_t StrComHandler::performFlashWrite() {
 #endif
   ReturnValue_t result = returnvalue::OK;
   uint32_t size = 0;
-  uint32_t bytesWritten = 0;
+  uint32_t bytesWrittenInRegion = 0;
+  size_t totalBytesWritten = 0;
   uint32_t fileSize = 0;
 
   struct WriteActionRequest req;
@@ -409,20 +425,18 @@ ReturnValue_t StrComHandler::performFlashWrite() {
   ProgressPrinter progressPrinter("Flash write", fileSize);
 #endif /* OBSW_DEBUG_STARTRACKER == 1 */
   uint32_t fileChunks = fileSize / CHUNK_SIZE;
-  bytesWritten = 0;
+  bytesWrittenInRegion = 0;
   req.region = flashWrite.firstRegion;
   req.length = CHUNK_SIZE;
-  for (uint32_t idx = 0; idx < fileChunks; idx++) {
-    if (terminate) {
-      return returnvalue::OK;
-    }
-    file.seekg(idx * CHUNK_SIZE, file.beg);
+
+  auto writeNextSegment = [&](uint32_t chunkIdx) {
+    file.seekg(chunkIdx * CHUNK_SIZE, file.beg);
     file.read(reinterpret_cast<char*>(req.data), CHUNK_SIZE);
-    if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
+    if (bytesWrittenInRegion + CHUNK_SIZE > FLASH_REGION_SIZE) {
       req.region++;
-      bytesWritten = 0;
+      bytesWrittenInRegion = 0;
     }
-    req.address = bytesWritten;
+    req.address = bytesWrittenInRegion;
     arc_pack_write_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
@@ -432,34 +446,49 @@ ReturnValue_t StrComHandler::performFlashWrite() {
     if (result != returnvalue::OK) {
       return result;
     }
-    bytesWritten += CHUNK_SIZE;
+    totalBytesWritten += CHUNK_SIZE;
+    bytesWrittenInRegion += CHUNK_SIZE;
 #if OBSW_DEBUG_STARTRACKER == 1
-    progressPrinter.print(idx * CHUNK_SIZE);
+    progressPrinter.print(chunkIdx * CHUNK_SIZE);
 #endif /* OBSW_DEBUG_STARTRACKER == 1 */
+    return result;
+  };
+
+  for (uint32_t idx = 0; idx < fileChunks; idx++) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    result = writeNextSegment(idx);
+    if (result != returnvalue::OK) {
+      return result;
+    }
     if (idx % 50 == 0) {
       // Some grace time for other tasks
       TaskFactory::delayTask(2);
     }
   }
   uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE;
-  file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg);
-  file.read(reinterpret_cast<char*>(req.data), remainingBytes);
-  file.close();
-  if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
-    req.region++;
-    bytesWritten = 0;
-  }
-  req.address = bytesWritten;
-  req.length = remainingBytes;
-  bytesWritten += remainingBytes;
-  arc_pack_write_action_req(&req, cmdBuf.data(), &size);
-  result = sendAndRead(size, req.address);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = checkActionReply(replyLen);
-  if (result != returnvalue::OK) {
-    return result;
+  if (remainingBytes > 0) {
+    file.seekg(fileChunks * CHUNK_SIZE, file.beg);
+    file.read(reinterpret_cast<char*>(req.data), remainingBytes);
+    file.close();
+    if (bytesWrittenInRegion + CHUNK_SIZE > FLASH_REGION_SIZE) {
+      req.region++;
+      bytesWrittenInRegion = 0;
+    }
+    req.address = bytesWrittenInRegion;
+    req.length = remainingBytes;
+    totalBytesWritten += CHUNK_SIZE;
+    bytesWrittenInRegion += remainingBytes;
+    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    result = sendAndRead(size, req.address);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
   }
 #if OBSW_DEBUG_STARTRACKER == 1
   progressPrinter.print(fileSize);
@@ -645,7 +674,8 @@ ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendDa
       return BUSY;
     }
   }
-  serial::flushRxBuf(serialPort);
+  // Ensure consistent state.
+  resetReplyHandlingState();
 
   const uint8_t* txFrame;
   size_t frameLen;
@@ -697,6 +727,7 @@ ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buf
     *buffer = const_cast<uint8_t*>(replyPtr);
     *size = replyLen;
   }
+  replyLen = 0;
   return replyResult;
 }
 
@@ -781,3 +812,8 @@ ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
     }
   }
 }
+
+void StrComHandler::resetReplyHandlingState() {
+  serial::flushRxBuf(serialPort);
+  datalinkLayer.reset();
+}

linux/acs/StrComHandler.h

@@ -11,8 +11,6 @@
 #include "bsp_q7s/fs/SdCardManager.h"
 #endif
 
-#include "arcsec/client/generated/actionreq.h"
-#include "arcsec/common/generated/tmtcstructs.h"
 #include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
@@ -174,7 +172,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
   static const uint32_t FLASH_REGION_SIZE = 0x20000;
 
   struct ImageDownload {
-    static const uint32_t LAST_POSITION = 4095;
+    static const uint32_t LAST_POSITION = 4096;
   };
 
   static const uint32_t MAX_POLLS = 10000;
@@ -374,6 +372,8 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
    * @return
    */
   ReturnValue_t readOneReply(uint32_t failParameter);
+
+  void resetReplyHandlingState();
 };
 
 #endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */

linux/acs/SusPolling.cpp

@@ -69,9 +69,12 @@ ReturnValue_t SusPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData,
   if (susDevs[susIdx].mode != susReq->mode) {
     if (susReq->mode == acs::SimpleSensorMode::NORMAL) {
       susDevs[susIdx].performStartup = true;
+      susDevs[susIdx].replyResult = returnvalue::FAILED;
     } else {
       susDevs[susIdx].ownReply.cfgWasSet = false;
       susDevs[susIdx].ownReply.dataWasSet = false;
+      // We are off now, but DHB wants a proper reply.
+      susDevs[susIdx].replyResult = returnvalue::OK;
     }
     susDevs[susIdx].mode = susReq->mode;
   }
@@ -95,11 +98,14 @@ ReturnValue_t SusPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer
   if (susIdx < 0) {
     return FAILED;
   }
+  if (susDevs[susIdx].replyResult != returnvalue::OK) {
+    return susDevs[susIdx].replyResult;
+  }
   MutexGuard mg(ipcLock);
   std::memcpy(&susDevs[susIdx].readerReply, &susDevs[susIdx].ownReply, sizeof(acs::SusReply));
   *buffer = reinterpret_cast<uint8_t*>(&susDevs[susIdx].readerReply);
   *size = sizeof(acs::SusReply);
-  return OK;
+  return susDevs[susIdx].replyResult;
 }
 
 ReturnValue_t SusPolling::handleSusPolling() {
@@ -164,11 +170,18 @@ ReturnValue_t SusPolling::handleSusPolling() {
       }
       MutexGuard mg(ipcLock);
       susDevs[idx].ownReply.tempRaw = ((rawReply[0] & 0x0f) << 8) | rawReply[1];
-      for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
-        susDevs[idx].ownReply.channelsRaw[chIdx] =
-            (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
+      // 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].ownReply.dataWasSet = true;
     }
   }
   return OK;

linux/boardtest/I2cTestClass.cpp

@@ -37,7 +37,7 @@ void I2cTestClass::battInit() {
   if (ioctl(bpxInfo.fd, I2C_SLAVE, bpxInfo.addr) < 0) {
     sif::error << "Failed to acquire bus access and/or talk to slave" << std::endl;
   }
-  cmdBuf[0] = BpxBattery::PORT_PING;
+  cmdBuf[0] = bpxBat::PORT_PING;
   cmdBuf[1] = 0x42;
   sendLen = 2;
   ReturnValue_t result = i2cWrite(bpxInfo.fd, cmdBuf.data(), sendLen);
@@ -66,7 +66,7 @@ void I2cTestClass::battPeriodic() {
   if (ioctl(bpxInfo.fd, I2C_SLAVE, bpxInfo.addr) < 0) {
     sif::error << "Failed to acquire bus access and/or talk to slave" << std::endl;
   }
-  cmdBuf[0] = BpxBattery::PORT_GET_HK;
+  cmdBuf[0] = bpxBat::PORT_GET_HK;
   sendLen = 1;
   ReturnValue_t result = i2cWrite(bpxInfo.fd, cmdBuf.data(), sendLen);
   if (result != returnvalue::OK) {

linux/com/SyrlinksComHandler.h

@@ -20,6 +20,7 @@ class SyrlinksComHandler : public DeviceCommunicationIF,
 
   //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t NO_SERIAL_DATA_READ = returnvalue::makeCode(2, 0);
+  //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t NO_PACKET_FOUND = returnvalue::makeCode(2, 1);
 
   enum class State { SLEEPING, ACTIVE } state = State::SLEEPING;

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 291 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateEvents.h"
 
@@ -97,6 +97,7 @@ const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 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 *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
@@ -160,8 +161,11 @@ const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
 const char *TOO_MANY_IRQS_STRING = "TOO_MANY_IRQS";
 const char *POLL_SYSCALL_ERROR_PDEC_STRING = "POLL_SYSCALL_ERROR_PDEC";
 const char *WRITE_SYSCALL_ERROR_PDEC_STRING = "WRITE_SYSCALL_ERROR_PDEC";
+const char *PDEC_TRYING_RESET_WITH_INIT_STRING = "PDEC_TRYING_RESET_WITH_INIT";
+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 *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";
@@ -209,11 +213,11 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING = "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
-const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING =
-    "SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903";
+const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903";
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
@@ -266,14 +270,17 @@ const char *VERSION_INFO_STRING = "VERSION_INFO";
 const char *CURRENT_IMAGE_INFO_STRING = "CURRENT_IMAGE_INFO";
 const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
-const char *I2C_UNAVAILABLE_REBOOT_STRING = "I2C_UNAVAILABLE_REBOOT";
+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 *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";
-const char *PLOC_OVERHEATING_STRING = "PLOC_OVERHEATING";
 const char *OBC_OVERHEATING_STRING = "OBC_OVERHEATING";
-const char *HPA_OVERHEATING_STRING = "HPA_OVERHEATING";
-const char *PLPCDU_OVERHEATING_STRING = "PLPCDU_OVERHEATING";
+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 *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";
@@ -477,8 +484,10 @@ const char *translateEvents(Event event) {
     case (11204):
       return MEKF_RECOVERY_STRING;
     case (11205):
-      return MEKF_INVALID_MODE_VIOLATION_STRING;
+      return MEKF_AUTOMATIC_RESET_STRING;
     case (11206):
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
+    case (11207):
       return SAFE_MODE_CONTROLLER_FAILURE_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
@@ -603,9 +612,15 @@ const char *translateEvents(Event event) {
     case (12409):
       return WRITE_SYSCALL_ERROR_PDEC_STRING;
     case (12410):
-      return PDEC_RESET_FAILED_STRING;
+      return PDEC_TRYING_RESET_WITH_INIT_STRING;
     case (12411):
+      return PDEC_TRYING_RESET_NO_INIT_STRING;
+    case (12412):
+      return PDEC_RESET_FAILED_STRING;
+    case (12413):
       return OPEN_IRQ_FILE_FAILED_STRING;
+    case (12414):
+      return PDEC_INIT_FAILED_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -700,6 +715,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):
@@ -813,21 +830,27 @@ const char *translateEvents(Event event) {
     case (14008):
       return INDIVIDUAL_BOOT_COUNTS_STRING;
     case (14010):
-      return I2C_UNAVAILABLE_REBOOT_STRING;
+      return TRYING_I2C_RECOVERY_STRING;
+    case (14011):
+      return I2C_REBOOT_STRING;
+    case (14012):
+      return PDEC_REBOOT_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
       return NO_HEALTHY_HEATER_AVAILABLE_STRING;
     case (14102):
       return SYRLINKS_OVERHEATING_STRING;
-    case (14103):
-      return PLOC_OVERHEATING_STRING;
     case (14104):
       return OBC_OVERHEATING_STRING;
     case (14105):
-      return HPA_OVERHEATING_STRING;
+      return CAMERA_OVERHEATING_STRING;
     case (14106):
-      return PLPCDU_OVERHEATING_STRING;
+      return PCDU_SYSTEM_OVERHEATING_STRING;
+    case (14107):
+      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
+    case (14108):
+      return MGT_OVERHEATING_STRING;
     case (14201):
       return TX_TIMER_EXPIRED_STRING;
     case (14202):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 173 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 175 translations.
+ * Generated on: 2023-04-17 11:34:19
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -244,6 +246,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

linux/ipcore/AxiPtmeConfig.cpp

@@ -1,5 +1,7 @@
 #include "AxiPtmeConfig.h"
 
+#include <fsfw/ipc/MutexGuard.h>
+
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw_hal/linux/uio/UioMapper.h"
 
@@ -39,97 +41,59 @@ ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
   return returnvalue::OK;
 }
 
-ReturnValue_t AxiPtmeConfig::enableTxclockManipulator() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::enableTxclockManipulator() {
+  writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR);
 }
 
-ReturnValue_t AxiPtmeConfig::disableTxclockManipulator() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::EN_TX_CLK_MANIPULATOR);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::disableTxclockManipulator() {
+  writeBit(COMMON_CONFIG_REG, false, BitPos::EN_TX_CLK_MANIPULATOR);
 }
 
-ReturnValue_t AxiPtmeConfig::enableTxclockInversion() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::INVERT_CLOCK);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::enableTxclockInversion() {
+  writeBit(COMMON_CONFIG_REG, true, BitPos::INVERT_CLOCK);
 }
 
-ReturnValue_t AxiPtmeConfig::disableTxclockInversion() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::INVERT_CLOCK);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::disableTxclockInversion() {
+  writeBit(COMMON_CONFIG_REG, false, BitPos::INVERT_CLOCK);
 }
 
-ReturnValue_t AxiPtmeConfig::enableBatPriorityBit() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::EN_BAT_PRIORITY);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::enableBatPriorityBit() {
+  writeBit(COMMON_CONFIG_REG, true, BitPos::EN_BAT_PRIORITY);
 }
 
-ReturnValue_t AxiPtmeConfig::disableBatPriorityBit() {
-  ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::EN_BAT_PRIORITY);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+void AxiPtmeConfig::disableBatPriorityBit() {
+  writeBit(COMMON_CONFIG_REG, false, BitPos::EN_BAT_PRIORITY);
 }
 
-ReturnValue_t AxiPtmeConfig::writeReg(uint32_t regOffset, uint32_t writeVal) {
-  ReturnValue_t result = returnvalue::OK;
-  result = mutex->lockMutex(timeoutType, mutexTimeout);
-  if (result != returnvalue::OK) {
-    sif::warning << "AxiPtmeConfig::readReg: Failed to lock mutex" << std::endl;
-    return returnvalue::FAILED;
-  }
+void AxiPtmeConfig::writeReg(uint32_t regOffset, uint32_t writeVal) {
+  MutexGuard mg(mutex, timeoutType, mutexTimeout);
   *(baseAddress + regOffset / ADRESS_DIVIDER) = writeVal;
-  result = mutex->unlockMutex();
-  if (result != returnvalue::OK) {
-    sif::warning << "AxiPtmeConfig::readReg: Failed to unlock mutex" << std::endl;
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
 }
 
-ReturnValue_t AxiPtmeConfig::readReg(uint32_t regOffset, uint32_t* readVal) {
-  ReturnValue_t result = returnvalue::OK;
-  result = mutex->lockMutex(timeoutType, mutexTimeout);
-  if (result != returnvalue::OK) {
-    sif::warning << "AxiPtmeConfig::readReg: Failed to lock mutex" << std::endl;
-    return returnvalue::FAILED;
-  }
-  *readVal = *(baseAddress + regOffset / ADRESS_DIVIDER);
-  result = mutex->unlockMutex();
-  if (result != returnvalue::OK) {
-    sif::warning << "AxiPtmeConfig::readReg: Failed to unlock mutex" << std::endl;
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
+uint32_t AxiPtmeConfig::readReg(uint32_t regOffset) {
+  MutexGuard mg(mutex, timeoutType, mutexTimeout);
+  return *(baseAddress + regOffset / ADRESS_DIVIDER);
 }
 
-ReturnValue_t AxiPtmeConfig::writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos) {
-  uint32_t readVal = 0;
-  ReturnValue_t result = readReg(regOffset, &readVal);
-  if (result != returnvalue::OK) {
-    return result;
-  }
+void AxiPtmeConfig::writePollThreshold(AxiPtmeConfig::IdlePollThreshold pollThreshold) {
+  uint32_t regVal = readCommonCfgReg();
+  // Clear bits first
+  regVal &= ~(0b111 << 3);
+  regVal |= (static_cast<uint8_t>(pollThreshold) << 3);
+  writeCommonCfgReg(regVal);
+}
+
+AxiPtmeConfig::IdlePollThreshold AxiPtmeConfig::readPollThreshold() {
+  uint32_t regVal = readCommonCfgReg();
+  return static_cast<AxiPtmeConfig::IdlePollThreshold>((regVal >> 3) & 0b111);
+}
+
+void AxiPtmeConfig::writeCommonCfgReg(uint32_t value) { writeReg(COMMON_CONFIG_REG, value); }
+uint32_t AxiPtmeConfig::readCommonCfgReg() { return readReg(COMMON_CONFIG_REG); }
+
+void AxiPtmeConfig::writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos) {
+  uint32_t readVal = readReg(regOffset);
   uint32_t writeVal =
       (readVal & ~(1 << static_cast<uint32_t>(bitPos))) | bitVal << static_cast<uint32_t>(bitPos);
-  result = writeReg(regOffset, writeVal);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
+  writeReg(regOffset, writeVal);
 }

linux/ipcore/AxiPtmeConfig.h

@@ -14,6 +14,16 @@
  */
 class AxiPtmeConfig : public SystemObject {
  public:
+  enum IdlePollThreshold : uint8_t {
+    ALWAYS = 0b000,
+    POLL_1 = 0b001,
+    POLL_4 = 0b010,
+    POLL_16 = 0b011,
+    POLL_64 = 0b100,
+    POLL_256 = 0b101,
+    POLL_1024 = 0b110,
+    NEVER = 0b111
+  };
   /**
    * @brief   Constructor
    * @param axiUio    Device file of UIO belonging to the AXI configuration interface.
@@ -40,8 +50,8 @@ class AxiPtmeConfig : public SystemObject {
    *            Default: Enables TX clock manipulator
    *
    */
-  ReturnValue_t enableTxclockManipulator();
-  ReturnValue_t disableTxclockManipulator();
+  void enableTxclockManipulator();
+  void disableTxclockManipulator();
 
   /**
    * @brief The next to functions control whether data will be updated on the rising or falling edge
@@ -51,11 +61,14 @@ class AxiPtmeConfig : public SystemObject {
    *        Disable clock inversion. Data updated on rising edge.
    *        Default: Inversion is disabled
    */
-  ReturnValue_t enableTxclockInversion();
-  ReturnValue_t disableTxclockInversion();
+  void enableTxclockInversion();
+  void disableTxclockInversion();
 
-  ReturnValue_t enableBatPriorityBit();
-  ReturnValue_t disableBatPriorityBit();
+  void enableBatPriorityBit();
+  void disableBatPriorityBit();
+
+  void writePollThreshold(IdlePollThreshold pollThreshold);
+  IdlePollThreshold readPollThreshold();
 
  private:
   // Address of register storing the bitrate configuration parameter
@@ -80,7 +93,7 @@ class AxiPtmeConfig : public SystemObject {
    *
    * @param writeVal    Value to write
    */
-  ReturnValue_t writeReg(uint32_t regOffset, uint32_t writeVal);
+  void writeReg(uint32_t regOffset, uint32_t writeVal);
 
   /**
    * @brief Reads value from configuration register
@@ -88,7 +101,10 @@ class AxiPtmeConfig : public SystemObject {
    * @param regOffset   Offset of register from base address to read from
    * Qparam readVal     Pointer to variable where read value will be written to
    */
-  ReturnValue_t readReg(uint32_t regOffset, uint32_t* readVal);
+  uint32_t readReg(uint32_t regOffset);
+
+  uint32_t readCommonCfgReg();
+  void writeCommonCfgReg(uint32_t value);
 
   /**
    * @brief Sets one bit in a register
@@ -99,7 +115,7 @@ class AxiPtmeConfig : public SystemObject {
    *
    * @return             returnvalue::OK if successful, otherwise returnvalue::FAILED
    */
-  ReturnValue_t writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos);
+  void writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos);
 };
 
 #endif /* LINUX_OBC_AXIPTMECONFIG_H_ */

linux/ipcore/PapbVcInterface.cpp

@@ -2,6 +2,7 @@
 #include <linux/ipcore/PapbVcInterface.h>
 #include <unistd.h>
 
+#include <cstring>
 #include <ctime>
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -18,29 +19,63 @@ PapbVcInterface::~PapbVcInterface() {}
 
 ReturnValue_t PapbVcInterface::initialize() {
   UioMapper uioMapper(uioFile, mapNum);
-  uint32_t* baseReg;
-  ReturnValue_t result = uioMapper.getMappedAdress(&baseReg, UioMapper::Permissions::WRITE_ONLY);
+  ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
+                                                   UioMapper::Permissions::WRITE_ONLY);
   if (result != returnvalue::OK) {
     return result;
   }
-  vcBaseReg = baseReg;
   return returnvalue::OK;
 }
 
 ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
-  if (pollPapbBusySignal(0) == returnvalue::OK) {
-    startPacketTransfer();
+  // There are no packets smaller than 4, this is considered a configuration error.
+  if (size < 4) {
+    return returnvalue::FAILED;
+  }
+  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
+    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 too often can mess up the scheduler.
+    // 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 (pollPapbBusySignal(2) == returnvalue::OK) {
+    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
       *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
     } else {
       abortPacketTransfer();
@@ -48,7 +83,7 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
     }
   }
   nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  if (pollPapbBusySignal(2) == returnvalue::OK) {
+  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
     completePacketTransfer();
   } else {
     abortPacketTransfer();
@@ -57,27 +92,29 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
   return returnvalue::OK;
 }
 
-void PapbVcInterface::startPacketTransfer() { *vcBaseReg = CONFIG_START; }
+void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
+  *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
+}
 
 void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
 
-ReturnValue_t PapbVcInterface::pollPapbBusySignal(uint32_t maxPollRetries) const {
-  gpio::Levels papbBusyState = gpio::Levels::LOW;
-  ReturnValue_t result;
+ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
+                                                      bool checkReadyState) const {
   uint32_t busyIdx = 0;
-  nextDelay.tv_nsec = 0;
+  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
 
   while (true) {
-    /** Check if PAPB interface is ready to receive data */
-    result = gpioComIF->readGpio(papbBusyId, papbBusyState);
-    if (result != returnvalue::OK) {
-      sif::warning << "PapbVcInterface::pollPapbBusySignal: Failed to read papb busy signal"
-                   << std::endl;
-      return returnvalue::FAILED;
-    }
-    if (papbBusyState == gpio::Levels::HIGH) {
+    // 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) {
@@ -87,9 +124,7 @@ ReturnValue_t PapbVcInterface::pollPapbBusySignal(uint32_t maxPollRetries) const
     // Ignore signal handling here for now.
     nanosleep(&nextDelay, &remDelay);
     // Adaptive delay.
-    if (nextDelay.tv_nsec == 0) {
-      nextDelay.tv_nsec = FIRST_NON_NULL_DELAY_NS;
-    } else if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
+    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
       nextDelay.tv_nsec *= 2;
     }
   }
@@ -116,7 +151,7 @@ void PapbVcInterface::isVcInterfaceBufferEmpty() {
   return;
 }
 
-bool PapbVcInterface::isBusy() const { return pollPapbBusySignal(0) == PAPB_BUSY; }
+bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }
 
 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }
 

linux/ipcore/PapbVcInterface.h

@@ -5,6 +5,8 @@
 #include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 #include <linux/ipcore/VirtualChannelIF.h>
 
+#include <atomic>
+
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
 
@@ -50,13 +52,14 @@ class PapbVcInterface : public VirtualChannelIF {
 
   static const ReturnValue_t PAPB_BUSY = MAKE_RETURN_CODE(0xA0);
 
+  enum ByteWidthCfg : uint32_t { ONE = 0b00, TWO = 0b01, THREE = 0b10, FOUR = 0b11 };
   /**
    * Configuration bits:
    * bit[1:0]: Size of data (1,2,3 or 4 bytes). 1 Byte <=> b00
    * bit[2]: Set this bit to 1 to abort a transferred packet
    * bit[3]: Signals to VcInterface the start of a new telemetry packet
    */
-  static constexpr uint32_t CONFIG_START = 0b00001000;
+  static constexpr uint32_t CONFIG_DATA_INPUT = 0b00001000;
 
   /**
    * Abort a transferred packet.
@@ -76,7 +79,7 @@ class PapbVcInterface : public VirtualChannelIF {
    */
   static const int DATA_REG_OFFSET = 256;
 
-  static constexpr long int FIRST_NON_NULL_DELAY_NS = 10;
+  static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
@@ -89,7 +92,7 @@ class PapbVcInterface : public VirtualChannelIF {
   std::string uioFile;
   int mapNum = 0;
   mutable struct timespec nextDelay = {.tv_sec = 0, .tv_nsec = 0};
-  const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 5};
+  const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 10};
   mutable struct timespec remDelay;
 
   volatile uint32_t* vcBaseReg = nullptr;
@@ -100,7 +103,7 @@ class PapbVcInterface : public VirtualChannelIF {
    * @brief   This function sends the config byte to the virtual channel of the PTME IP Core
    *          to initiate a packet transfer.
    */
-  void startPacketTransfer();
+  void startPacketTransfer(ByteWidthCfg initWidth);
 
   void abortPacketTransfer();
 
@@ -117,7 +120,7 @@ class PapbVcInterface : public VirtualChannelIF {
    *
    * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
    */
-  inline ReturnValue_t pollPapbBusySignal(uint32_t maxPollRetries) const;
+  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;
 
   /**
    * @brief   This function can be used for debugging to check whether there are packets in

linux/ipcore/PdecHandler.cpp

@@ -15,6 +15,7 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 #include "fsfw_hal/linux/uio/UioMapper.h"
+#include "linux/ipcore/PdecConfig.h"
 #include "pdec.h"
 
 using namespace pdec;
@@ -103,21 +104,10 @@ ReturnValue_t PdecHandler::firstLoop() {
 
   result = releasePdec();
   if (result != returnvalue::OK) {
-    return returnvalue::FAILED;
-  }
-
-  // This configuration must be done while the PDEC is not held in reset.
-  if (OP_MODE == Modes::IRQ) {
-    // Configure interrupt mask register to enable interrupts
-    *(registerBaseAddress + PDEC_IMR_OFFSET) = pdecConfig.getImrReg();
-  }
-  result = resetFarStatFlag();
-  if (result != returnvalue::OK) {
-    // Requires reconfiguration and reinitialization of PDEC
-    triggerEvent(INVALID_FAR);
     return result;
   }
-  return returnvalue::OK;
+
+  return postResetOperation();
 }
 
 ReturnValue_t PdecHandler::performOperation(uint8_t operationCode) {
@@ -141,10 +131,11 @@ ReturnValue_t PdecHandler::polledOperation() {
       if (newTcReceived()) {
         handleNewTc();
       }
-      checkLocks();
+      doPeriodicWork();
       break;
     }
     case State::PDEC_RESET: {
+      triggerEvent(pdec::PDEC_TRYING_RESET_WITH_INIT);
       ReturnValue_t result = pdecToReset();
       if (result != returnvalue::OK) {
         triggerEvent(PDEC_RESET_FAILED);
@@ -165,8 +156,8 @@ ReturnValue_t PdecHandler::polledOperation() {
 // See https://yurovsky.github.io/2014/10/10/linux-uio-gpio-interrupt.html for more information.
 ReturnValue_t PdecHandler::irqOperation() {
   ReturnValue_t result = returnvalue::OK;
-  int fd = -1;
-  // Used to unmask IRQ
+  // int fd = -1;
+  //  Used to unmask IRQ
   uint32_t info = 1;
 
   interruptWindowCd.resetTimer();
@@ -182,22 +173,29 @@ ReturnValue_t PdecHandler::irqOperation() {
     switch (state) {
       case State::INIT: {
         result = handleInitState();
-        if (result == returnvalue::OK) {
-          openIrqFile(&fd);
+        if (result != returnvalue::OK) {
+          break;
+        }
+        openIrqFile();
+        if (ptmeResetWithReinitializationPending) {
+          actionHelper.finish(true, commandedBy, pdec::RESET_PDEC_WITH_REINIITALIZATION);
+          ptmeResetWithReinitializationPending = false;
         }
         break;
       }
       case State::PDEC_RESET: {
+        triggerEvent(pdec::PDEC_TRYING_RESET_WITH_INIT);
         result = pdecToReset();
         if (result != returnvalue::OK) {
           triggerEvent(PDEC_RESET_FAILED);
         }
+        usleep(20);
         state = State::INIT;
         break;
       }
       case State::RUNNING: {
-        checkLocks();
-        checkAndHandleIrqs(fd, info);
+        doPeriodicWork();
+        checkAndHandleIrqs(info);
         break;
       }
       case State::WAIT_FOR_RECOVERY:
@@ -219,27 +217,28 @@ ReturnValue_t PdecHandler::handleInitState() {
   ReturnValue_t result = firstLoop();
   if (result != returnvalue::OK) {
     if (result == LocalParameterHandler::SD_NOT_READY) {
-      TaskFactory::delayTask(400);
       if (initTries == MAX_INIT_TRIES) {
-        sif::error << "PdecHandler::handleInitState: SD card never "
-                      "becomes ready"
-                   << std::endl;
-        state = State::WAIT_FOR_RECOVERY;
-      } else {
-        state = State::INIT;
+        sif::error << "PdecHandler::handleInitState: SD card never becomes ready" << std::endl;
+        initFailedHandler(result);
+        return result;
       }
+      state = State::INIT;
+      initTries++;
+      TaskFactory::delayTask(400);
       return result;
     }
-    state = State::WAIT_FOR_RECOVERY;
+    sif::error << "PDEC: Init failed with reason 0x" << std::hex << std::setw(4) << result
+               << std::endl;
+    initFailedHandler(result);
     return result;
   }
   state = State::RUNNING;
   return returnvalue::OK;
 }
 
-void PdecHandler::openIrqFile(int* fd) {
-  *fd = open(uioNames.irq, O_RDWR);
-  if (*fd < 0) {
+void PdecHandler::openIrqFile() {
+  irqFd = open(uioNames.irq, O_RDWR);
+  if (irqFd < 0) {
     sif::error << "PdecHandler::irqOperation: Opening UIO IRQ file" << uioNames.irq << " failed"
                << std::endl;
     triggerEvent(OPEN_IRQ_FILE_FAILED);
@@ -247,16 +246,16 @@ void PdecHandler::openIrqFile(int* fd) {
   }
 }
 
-ReturnValue_t PdecHandler::checkAndHandleIrqs(int fd, uint32_t& info) {
-  ssize_t nb = write(fd, &info, sizeof(info));
+ReturnValue_t PdecHandler::checkAndHandleIrqs(uint32_t& info) {
+  ssize_t nb = write(irqFd, &info, sizeof(info));
   if (nb != static_cast<ssize_t>(sizeof(info))) {
     sif::error << "PdecHandler::irqOperation: Unmasking IRQ failed" << std::endl;
     triggerEvent(WRITE_SYSCALL_ERROR_PDEC, errno);
-    close(fd);
+    close(irqFd);
     state = State::INIT;
     return returnvalue::FAILED;
   }
-  struct pollfd fds = {.fd = fd, .events = POLLIN, .revents = 0};
+  struct pollfd fds = {.fd = irqFd, .events = POLLIN, .revents = 0};
   int ret = poll(&fds, 1, IRQ_TIMEOUT_MS);
   if (ret == 0) {
     // No TCs for timeout period
@@ -264,7 +263,7 @@ ReturnValue_t PdecHandler::checkAndHandleIrqs(int fd, uint32_t& info) {
     resetIrqLimiters();
   } else if (ret >= 1) {
     // Interrupt handling.
-    nb = read(fd, &info, sizeof(info));
+    nb = read(irqFd, &info, sizeof(info));
     interruptCounter++;
     if (nb == static_cast<ssize_t>(sizeof(info))) {
       uint32_t pisr = *(registerBaseAddress + PDEC_PISR_OFFSET);
@@ -303,7 +302,7 @@ ReturnValue_t PdecHandler::checkAndHandleIrqs(int fd, uint32_t& info) {
     sif::error << "PdecHandler::irqOperation: Poll error with errno " << errno << ": "
                << strerror(errno) << std::endl;
     triggerEvent(POLL_SYSCALL_ERROR_PDEC, errno);
-    close(fd);
+    close(irqFd);
     state = State::INIT;
     return returnvalue::FAILED;
   }
@@ -335,6 +334,7 @@ MessageQueueId_t PdecHandler::getCommandQueue() const { return commandQueue->get
 
 ReturnValue_t PdecHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                          const uint8_t* data, size_t size) {
+  using namespace pdec;
   switch (actionId) {
     case PRINT_CLCW:
       printClcw();
@@ -342,6 +342,16 @@ ReturnValue_t PdecHandler::executeAction(ActionId_t actionId, MessageQueueId_t c
     case PRINT_PDEC_MON:
       printPdecMon();
       return EXECUTION_FINISHED;
+    case RESET_PDEC_NO_REINIITALIZATION: {
+      pdecResetNoInit();
+      return EXECUTION_FINISHED;
+    }
+    case RESET_PDEC_WITH_REINIITALIZATION: {
+      initializeReset();
+      ptmeResetWithReinitializationPending = true;
+      this->commandedBy = commandedBy;
+      return returnvalue::OK;
+    }
     default:
       return COMMAND_NOT_IMPLEMENTED;
   }
@@ -370,7 +380,7 @@ ReturnValue_t PdecHandler::getParameter(uint8_t domainId, uint8_t uniqueIdentifi
       return returnvalue::FAILED;
     }
     // PDEC needs reset to apply this parameter change
-    state = State::PDEC_RESET;
+    initializeReset();
     return returnvalue::OK;
   } else if ((domainId == 0) and (uniqueIdentifier == ParameterId::NEGATIVE_WINDOW)) {
     uint8_t newVal = 0;
@@ -392,7 +402,7 @@ ReturnValue_t PdecHandler::getParameter(uint8_t domainId, uint8_t uniqueIdentifi
       return returnvalue::FAILED;
     }
     // PDEC needs reset to apply this parameter change
-    state = State::PDEC_RESET;
+    initializeReset();
     return returnvalue::OK;
   }
   return returnvalue::OK;
@@ -425,8 +435,7 @@ ReturnValue_t PdecHandler::releasePdec() {
 }
 
 ReturnValue_t PdecHandler::pdecToReset() {
-  ReturnValue_t result = returnvalue::OK;
-  result = gpioComIF->pullLow(pdecReset);
+  ReturnValue_t result = gpioComIF->pullLow(pdecReset);
   if (result != returnvalue::OK) {
     sif::error << "PdecHandler::pdecToReset: Failed to pull PDEC reset line"
                   " to low"
@@ -449,22 +458,13 @@ bool PdecHandler::newTcReceived() {
   return true;
 }
 
-void PdecHandler::checkLocks() {
-  uint32_t clcw = getClcw();
-  if (not(clcw & NO_RF_MASK) && not carrierLock) {
-    triggerEvent(CARRIER_LOCK);
-    carrierLock = true;
-  } else if ((clcw & NO_RF_MASK) && carrierLock) {
-    carrierLock = false;
-    triggerEvent(LOST_CARRIER_LOCK_PDEC);
-  }
-  if (not(clcw & NO_BITLOCK_MASK) && not bitLock) {
-    triggerEvent(BIT_LOCK_PDEC);
-    bitLock = true;
-  } else if ((clcw & NO_BITLOCK_MASK) && bitLock) {
-    bitLock = false;
-    triggerEvent(LOST_BIT_LOCK_PDEC);
-  }
+void PdecHandler::doPeriodicWork() {
+  // scuffed test code
+  //  if(testCntr < 30) {
+  //    triggerEvent(pdec::INVALID_TC_FRAME, FRAME_DIRTY_RETVAL);
+  //    testCntr++;
+  //  }
+  checkLocks();
 }
 
 bool PdecHandler::checkFrameAna(uint32_t pdecFar) {
@@ -748,6 +748,68 @@ void PdecHandler::resetIrqLimiters() {
   interruptCounter = 0;
 }
 
+void PdecHandler::checkLocks() {
+  uint32_t clcw = getClcw();
+  if (not(clcw & NO_RF_MASK) && not carrierLock) {
+    triggerEvent(CARRIER_LOCK);
+    carrierLock = true;
+  } else if ((clcw & NO_RF_MASK) && carrierLock) {
+    carrierLock = false;
+    triggerEvent(LOST_CARRIER_LOCK_PDEC);
+  }
+  if (not(clcw & NO_BITLOCK_MASK) && not bitLock) {
+    triggerEvent(BIT_LOCK_PDEC);
+    bitLock = true;
+  } else if ((clcw & NO_BITLOCK_MASK) && bitLock) {
+    bitLock = false;
+    triggerEvent(LOST_BIT_LOCK_PDEC);
+  }
+}
+
+void PdecHandler::initFailedHandler(ReturnValue_t reason) {
+  triggerEvent(pdec::PDEC_INIT_FAILED, reason, 0);
+  if (ptmeResetWithReinitializationPending) {
+    actionHelper.finish(false, commandedBy, pdec::RESET_PDEC_WITH_REINIITALIZATION, reason);
+    ptmeResetWithReinitializationPending = false;
+  }
+  state = State::WAIT_FOR_RECOVERY;
+}
+
+void PdecHandler::pdecResetNoInit() {
+  triggerEvent(pdec::PDEC_TRYING_RESET_NO_INIT);
+  pdecToReset();
+  usleep(20);
+  releasePdec();
+  ReturnValue_t result = postResetOperation();
+  if (result != returnvalue::OK) {
+    // What can we really do here? Event was already triggered if this is due to the FAR flag
+    // not being reset.
+    sif::error << "PdecHandler::pdecResetNoInit: Post reset operation failed unexpectedly"
+               << std::endl;
+  }
+}
+
+ReturnValue_t PdecHandler::postResetOperation() {
+  // This configuration must be done while the PDEC is not held in reset.
+  if (OP_MODE == Modes::IRQ) {
+    // Configure interrupt mask register to enable interrupts
+    *(registerBaseAddress + PDEC_IMR_OFFSET) = pdecConfig.getImrReg();
+  }
+  ReturnValue_t result = resetFarStatFlag();
+  if (result != returnvalue::OK) {
+    // Requires reconfiguration and reinitialization of PDEC
+    triggerEvent(INVALID_FAR);
+  }
+  return result;
+}
+
+void PdecHandler::initializeReset() {
+  if (irqFd != 0) {
+    close(irqFd);
+  }
+  state = State::PDEC_RESET;
+}
+
 std::string PdecHandler::getMonStatusString(uint32_t status) {
   switch (status) {
     case TC_CHANNEL_INACTIVE:

linux/ipcore/PdecHandler.h

@@ -3,6 +3,8 @@
 
 #include <fsfw/timemanager/Countdown.h>
 
+#include <atomic>
+
 #include "OBSWConfig.h"
 #include "PdecConfig.h"
 #include "eive/definitions.h"
@@ -79,73 +81,11 @@ class PdecHandler : public SystemObject,
                              ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
                              uint16_t startAtIndex) override;
 
-  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PDEC_HANDLER;
-
-  //! [EXPORT] : [COMMENT] Frame acceptance report signals an invalid frame
-  //! P1: The frame analysis information (FrameAna field of PDEC_FAR register)
-  //! P2: When frame declared illegal this parameter this parameter gives information about the
-  //! reason (IReason field of the PDEC_FAR register)
-  static const Event INVALID_TC_FRAME = MAKE_EVENT(1, severity::HIGH);
-  //! [EXPORT] : [COMMENT] Read invalid FAR from PDEC after startup
-  static const Event INVALID_FAR = MAKE_EVENT(2, severity::HIGH);
-  //! [EXPORT] : [COMMENT] Carrier lock detected
-  static const Event CARRIER_LOCK = MAKE_EVENT(3, severity::INFO);
-  //! [EXPORT] : [COMMENT] Bit lock detected (data valid)
-  static const Event BIT_LOCK_PDEC = MAKE_EVENT(4, severity::INFO);
-  //! [EXPORT] : [COMMENT] Lost carrier lock
-  static const Event LOST_CARRIER_LOCK_PDEC = MAKE_EVENT(5, severity::INFO);
-  //! [EXPORT] : [COMMENT] Lost bit lock
-  static const Event LOST_BIT_LOCK_PDEC = MAKE_EVENT(6, severity::INFO);
-  //! [EXPORT] : [COMMENT] Too many IRQs over the time window of one second. P1: Allowed TCs
-  static constexpr Event TOO_MANY_IRQS = MAKE_EVENT(7, severity::MEDIUM);
-  static constexpr Event POLL_SYSCALL_ERROR_PDEC =
-      event::makeEvent(SUBSYSTEM_ID, 8, severity::MEDIUM);
-  static constexpr Event WRITE_SYSCALL_ERROR_PDEC =
-      event::makeEvent(SUBSYSTEM_ID, 9, severity::HIGH);
-  //! [EXPORT] : [COMMENT] Failed to pull PDEC reset to low
-  static constexpr Event PDEC_RESET_FAILED = event::makeEvent(SUBSYSTEM_ID, 10, severity::HIGH);
-  //! [EXPORT] : [COMMENT] Failed to open the IRQ uio file
-  static constexpr Event OPEN_IRQ_FILE_FAILED = event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
-
  private:
-  static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;
-
   static constexpr Modes OP_MODE = Modes::IRQ;
 
-  static const ReturnValue_t ABANDONED_CLTU_RETVAL = MAKE_RETURN_CODE(0xA0);
-  static const ReturnValue_t FRAME_DIRTY_RETVAL = MAKE_RETURN_CODE(0xA1);
-  static const ReturnValue_t FRAME_ILLEGAL_ONE_REASON = MAKE_RETURN_CODE(0xA2);
-  static const ReturnValue_t FRAME_ILLEGAL_MULTIPLE_REASONS = MAKE_RETURN_CODE(0xA2);
-  static const ReturnValue_t AD_DISCARDED_LOCKOUT_RETVAL = MAKE_RETURN_CODE(0xA3);
-  static const ReturnValue_t AD_DISCARDED_WAIT_RETVAL = MAKE_RETURN_CODE(0xA4);
-  static const ReturnValue_t AD_DISCARDED_NS_VS = MAKE_RETURN_CODE(0xA5);
-
-  //! [EXPORT] : [COMMENT] Received action message with unknown action id
-  static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xB0);
-
-  static const ReturnValue_t NO_REPORT_RETVAL = MAKE_RETURN_CODE(0xA6);
-  //! Error in version number and reserved A and B fields
-  static const ReturnValue_t ERROR_VERSION_NUMBER_RETVAL = MAKE_RETURN_CODE(0xA7);
-  //! Illegal combination of bypass and control command flag
-  static const ReturnValue_t ILLEGAL_COMBINATION_RETVAL = MAKE_RETURN_CODE(0xA8);
-  //! Spacecraft identifier did not match
-  static const ReturnValue_t INVALID_SC_ID_RETVAL = MAKE_RETURN_CODE(0xA9);
-  //! VC identifier bits 0 to 4 did not match
-  static const ReturnValue_t INVALID_VC_ID_MSB_RETVAL = MAKE_RETURN_CODE(0xAA);
-  //! VC identifier bit 5 did not match
-  static const ReturnValue_t INVALID_VC_ID_LSB_RETVAL = MAKE_RETURN_CODE(0xAB);
-  //! N(S) of BC or BD frame not set to all zeros
-  static const ReturnValue_t NS_NOT_ZERO_RETVAL = MAKE_RETURN_CODE(0xAC);
-  //! Invalid BC control command
-  static const ReturnValue_t INVALID_BC_CC = MAKE_RETURN_CODE(0xAE);
-
   static const uint32_t QUEUE_SIZE = config::CCSDS_HANDLER_QUEUE_SIZE;
 
-  // Action IDs
-  static const ActionId_t PRINT_CLCW = 0;
-  // Print PDEC monitor register
-  static const ActionId_t PRINT_PDEC_MON = 1;
-
 #ifdef TE0720_1CFA
   static const int CONFIG_MEMORY_MAP_SIZE = 0x400;
   static const int RAM_MAP_SIZE = 0x4000;
@@ -185,17 +125,6 @@ class PdecHandler : public SystemObject,
 
   static constexpr uint32_t MAX_ALLOWED_IRQS_PER_WINDOW = 800;
 
-  enum class FrameAna_t : uint8_t {
-    ABANDONED_CLTU,
-    FRAME_DIRTY,
-    FRAME_ILLEGAL,
-    FRAME_ILLEGAL_MULTI_REASON,
-    AD_DISCARDED_LOCKOUT,
-    AD_DISCARDED_WAIT,
-    AD_DISCARDED_NS_VR,
-    FRAME_ACCEPTED
-  };
-
   enum class IReason_t : uint8_t {
     NO_REPORT,
     ERROR_VERSION_NUMBER,
@@ -213,6 +142,7 @@ class PdecHandler : public SystemObject,
 
   Countdown genericCheckCd = Countdown(IRQ_TIMEOUT_MS);
   object_id_t tcDestinationId;
+  int irqFd = 0;
 
   AcceptsTelecommandsIF* tcDestination = nullptr;
 
@@ -258,6 +188,9 @@ class PdecHandler : public SystemObject,
   bool carrierLock = false;
   bool bitLock = false;
 
+  MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
+  bool ptmeResetWithReinitializationPending = false;
+
   UioNames uioNames;
 
   ParameterHelper paramHelper;
@@ -266,6 +199,9 @@ class PdecHandler : public SystemObject,
 
   uint32_t initTries = 0;
 
+  // scuffed test counter.
+  uint8_t testCntr = 0;
+
   /**
    * @brief	Performs initialization stuff which must be performed in first
    * 				loop of running task
@@ -282,8 +218,8 @@ class PdecHandler : public SystemObject,
   ReturnValue_t polledOperation();
   ReturnValue_t irqOperation();
   ReturnValue_t handleInitState();
-  void openIrqFile(int* fd);
-  ReturnValue_t checkAndHandleIrqs(int fd, uint32_t& info);
+  void openIrqFile();
+  ReturnValue_t checkAndHandleIrqs(uint32_t& info);
 
   uint32_t readFar();
 
@@ -325,6 +261,8 @@ class PdecHandler : public SystemObject,
    * @brief   Checks if carrier lock or bit lock has been detected and triggers appropriate
    *          event.
    */
+  void doPeriodicWork();
+
   void checkLocks();
 
   void resetIrqLimiters();
@@ -400,6 +338,13 @@ class PdecHandler : public SystemObject,
    */
   void printPdecMon();
 
+  void pdecResetNoInit();
+
+  ReturnValue_t postResetOperation();
+  void initializeReset();
+
+  void initFailedHandler(ReturnValue_t reason);
+
   std::string getMonStatusString(uint32_t status);
 };
 

linux/ipcore/PtmeConfig.cpp

@@ -26,33 +26,30 @@ ReturnValue_t PtmeConfig::setRate(uint32_t bitRate) {
   return axiPtmeConfig->writeCaduRateReg(static_cast<uint8_t>(rateVal));
 }
 
-ReturnValue_t PtmeConfig::invertTxClock(bool invert) {
-  ReturnValue_t result = returnvalue::OK;
+void PtmeConfig::invertTxClock(bool invert) {
   if (invert) {
-    result = axiPtmeConfig->enableTxclockInversion();
+    axiPtmeConfig->enableTxclockInversion();
   } else {
-    result = axiPtmeConfig->disableTxclockInversion();
+    axiPtmeConfig->disableTxclockInversion();
   }
-  if (result != returnvalue::OK) {
-    return CLK_INVERSION_FAILED;
-  }
-  return result;
 }
 
-ReturnValue_t PtmeConfig::configTxManipulator(bool enable) {
-  ReturnValue_t result = returnvalue::OK;
+void PtmeConfig::configTxManipulator(bool enable) {
   if (enable) {
-    result = axiPtmeConfig->enableTxclockManipulator();
+    axiPtmeConfig->enableTxclockManipulator();
   } else {
-    result = axiPtmeConfig->disableTxclockManipulator();
+    axiPtmeConfig->disableTxclockManipulator();
   }
-  return result;
 }
 
-ReturnValue_t PtmeConfig::enableBatPriorityBit(bool enable) {
+void PtmeConfig::enableBatPriorityBit(bool enable) {
   if (enable) {
-    return axiPtmeConfig->enableBatPriorityBit();
+    axiPtmeConfig->enableBatPriorityBit();
   } else {
-    return axiPtmeConfig->disableBatPriorityBit();
+    axiPtmeConfig->disableBatPriorityBit();
   }
 }
+
+void PtmeConfig::setPollThreshold(AxiPtmeConfig::IdlePollThreshold pollThreshold) {
+  axiPtmeConfig->writePollThreshold(pollThreshold);
+}

linux/ipcore/PtmeConfig.h

@@ -43,7 +43,7 @@ class PtmeConfig : public SystemObject {
    *
    * @return        REUTRN_OK if successful, otherwise error return value
    */
-  ReturnValue_t invertTxClock(bool invert);
+  void invertTxClock(bool invert);
 
   /**
    * @brief Controls the tx clock manipulator of the PTME wrapper component
@@ -53,7 +53,7 @@ class PtmeConfig : public SystemObject {
    *
    * @return        REUTRN_OK if successful, otherwise error return value
    */
-  ReturnValue_t configTxManipulator(bool enable);
+  void configTxManipulator(bool enable);
 
   /**
    * Enable the bat priority bit in the PTME wrapper component.
@@ -62,7 +62,9 @@ class PtmeConfig : public SystemObject {
    * @param enable
    * @return
    */
-  ReturnValue_t enableBatPriorityBit(bool enable);
+  void enableBatPriorityBit(bool enable);
+
+  void setPollThreshold(AxiPtmeConfig::IdlePollThreshold pollThreshold);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::RATE_SETTER;

linux/ipcore/pdec.h

@@ -1,10 +1,95 @@
 #ifndef LINUX_OBC_PDEC_H_
 #define LINUX_OBC_PDEC_H_
 
+#include <eive/resultClassIds.h>
+#include <fsfw/action/ActionMessage.h>
+
 #include <cstdint>
 
 namespace pdec {
 
+static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;
+static const ReturnValue_t ABANDONED_CLTU_RETVAL = MAKE_RETURN_CODE(0xA0);
+static const ReturnValue_t FRAME_DIRTY_RETVAL = MAKE_RETURN_CODE(0xA1);
+static const ReturnValue_t FRAME_ILLEGAL_ONE_REASON = MAKE_RETURN_CODE(0xA2);
+static const ReturnValue_t FRAME_ILLEGAL_MULTIPLE_REASONS = MAKE_RETURN_CODE(0xA2);
+static const ReturnValue_t AD_DISCARDED_LOCKOUT_RETVAL = MAKE_RETURN_CODE(0xA3);
+static const ReturnValue_t AD_DISCARDED_WAIT_RETVAL = MAKE_RETURN_CODE(0xA4);
+static const ReturnValue_t AD_DISCARDED_NS_VS = MAKE_RETURN_CODE(0xA5);
+
+//! [EXPORT] : [COMMENT] Received action message with unknown action id
+static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xB0);
+
+static const ReturnValue_t NO_REPORT_RETVAL = MAKE_RETURN_CODE(0xA6);
+//! Error in version number and reserved A and B fields
+static const ReturnValue_t ERROR_VERSION_NUMBER_RETVAL = MAKE_RETURN_CODE(0xA7);
+//! Illegal combination of bypass and control command flag
+static const ReturnValue_t ILLEGAL_COMBINATION_RETVAL = MAKE_RETURN_CODE(0xA8);
+//! Spacecraft identifier did not match
+static const ReturnValue_t INVALID_SC_ID_RETVAL = MAKE_RETURN_CODE(0xA9);
+//! VC identifier bits 0 to 4 did not match
+static const ReturnValue_t INVALID_VC_ID_MSB_RETVAL = MAKE_RETURN_CODE(0xAA);
+//! VC identifier bit 5 did not match
+static const ReturnValue_t INVALID_VC_ID_LSB_RETVAL = MAKE_RETURN_CODE(0xAB);
+//! N(S) of BC or BD frame not set to all zeros
+static const ReturnValue_t NS_NOT_ZERO_RETVAL = MAKE_RETURN_CODE(0xAC);
+//! Invalid BC control command
+static const ReturnValue_t INVALID_BC_CC = MAKE_RETURN_CODE(0xAE);
+
+static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PDEC_HANDLER;
+
+//! [EXPORT] : [COMMENT] Frame acceptance report signals an invalid frame
+//! P1: The frame analysis information (FrameAna field of PDEC_FAR register)
+//! P2: When frame declared illegal this parameter this parameter gives information about the
+//! reason (IReason field of the PDEC_FAR register)
+static const Event INVALID_TC_FRAME = MAKE_EVENT(1, severity::HIGH);
+//! [EXPORT] : [COMMENT] Read invalid FAR from PDEC after startup
+static const Event INVALID_FAR = MAKE_EVENT(2, severity::HIGH);
+//! [EXPORT] : [COMMENT] Carrier lock detected
+static const Event CARRIER_LOCK = MAKE_EVENT(3, severity::INFO);
+//! [EXPORT] : [COMMENT] Bit lock detected (data valid)
+static const Event BIT_LOCK_PDEC = MAKE_EVENT(4, severity::INFO);
+//! [EXPORT] : [COMMENT] Lost carrier lock
+static const Event LOST_CARRIER_LOCK_PDEC = MAKE_EVENT(5, severity::INFO);
+//! [EXPORT] : [COMMENT] Lost bit lock
+static const Event LOST_BIT_LOCK_PDEC = MAKE_EVENT(6, severity::INFO);
+//! [EXPORT] : [COMMENT] Too many IRQs over the time window of one second. P1: Allowed TCs
+static constexpr Event TOO_MANY_IRQS = MAKE_EVENT(7, severity::MEDIUM);
+static constexpr Event POLL_SYSCALL_ERROR_PDEC =
+    event::makeEvent(SUBSYSTEM_ID, 8, severity::MEDIUM);
+static constexpr Event WRITE_SYSCALL_ERROR_PDEC = event::makeEvent(SUBSYSTEM_ID, 9, severity::HIGH);
+//! [EXPORT] : [COMMENT] Trying a PDEC reset with complete re-initialization
+static constexpr Event PDEC_TRYING_RESET_WITH_INIT =
+    event::makeEvent(SUBSYSTEM_ID, 10, severity::LOW);
+//! [EXPORT] : [COMMENT] Trying a PDEC reset without re-initialization.
+static constexpr Event PDEC_TRYING_RESET_NO_INIT =
+    event::makeEvent(SUBSYSTEM_ID, 11, severity::LOW);
+//! [EXPORT] : [COMMENT] Failed to pull PDEC reset to low
+static constexpr Event PDEC_RESET_FAILED = event::makeEvent(SUBSYSTEM_ID, 12, severity::HIGH);
+//! [EXPORT] : [COMMENT] Failed to open the IRQ uio file
+static constexpr Event OPEN_IRQ_FILE_FAILED = event::makeEvent(SUBSYSTEM_ID, 13, severity::HIGH);
+//! [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);
+
+// Action IDs
+static constexpr ActionId_t PRINT_CLCW = 0;
+// Print PDEC monitor register
+static constexpr ActionId_t PRINT_PDEC_MON = 1;
+static constexpr ActionId_t RESET_PDEC_NO_REINIITALIZATION = 2;
+static constexpr ActionId_t RESET_PDEC_WITH_REINIITALIZATION = 3;
+
+enum class FrameAna_t : uint8_t {
+  ABANDONED_CLTU,
+  FRAME_DIRTY,
+  FRAME_ILLEGAL,
+  FRAME_ILLEGAL_MULTI_REASON,
+  AD_DISCARDED_LOCKOUT,
+  AD_DISCARDED_WAIT,
+  AD_DISCARDED_NS_VR,
+  FRAME_ACCEPTED
+};
+
 static const uint8_t STAT_POSITION = 31;
 static const uint8_t FRAME_ANA_POSITION = 28;
 static const uint8_t IREASON_POSITION = 25;

linux/payload/ScexHelper.h

@@ -10,6 +10,7 @@
 
 class ScexHelper : public SerializeIF {
  public:
+  //! [EXPORT] : [SKIP]
   static const ReturnValue_t INVALID_CRC = returnvalue::makeCode(0, 2);
 
   ScexHelper();

mission/SolarArrayDeploymentHandler.cpp

@@ -17,7 +17,7 @@ static constexpr bool DEBUG_MODE = true;
 SolarArrayDeploymentHandler::SolarArrayDeploymentHandler(object_id_t setObjectId_,
                                                          GpioIF& gpioInterface,
                                                          PowerSwitchIF& mainLineSwitcher_,
-                                                         pcdu::Switches mainLineSwitch_,
+                                                         power::Switches mainLineSwitch_,
                                                          gpioId_t deplSA1, gpioId_t deplSA2,
                                                          SdCardMountedIF& sdcMountedIF)
     : SystemObject(setObjectId_),

mission/SolarArrayDeploymentHandler.h

@@ -107,7 +107,7 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
    * @param burnTimeMs  Time duration the power will be applied to the burn wires.
    */
   SolarArrayDeploymentHandler(object_id_t setObjectId, GpioIF& gpio,
-                              PowerSwitchIF& mainLineSwitcher, pcdu::Switches mainLineSwitch,
+                              PowerSwitchIF& mainLineSwitcher, power::Switches mainLineSwitch,
                               gpioId_t deplSA1, gpioId_t deplSA2, SdCardMountedIF& sdcMountedIF);
 
   virtual ~SolarArrayDeploymentHandler();

mission/acs/GyrAdis1650XHandler.cpp

@@ -37,6 +37,7 @@ void GyrAdis1650XHandler::doStartUp() {
 void GyrAdis1650XHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
     commandExecuted = false;
+    PoolReadGuard pg(&primaryDataset);
     primaryDataset.setValidity(false, true);
     internalState = InternalState::SHUTDOWN;
   }
@@ -56,6 +57,9 @@ ReturnValue_t GyrAdis1650XHandler::buildNormalDeviceCommand(DeviceCommandId_t *i
 ReturnValue_t GyrAdis1650XHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
   switch (internalState) {
     case (InternalState::STARTUP): {
+      if (breakCountdown.isBusy()) {
+        return NOTHING_TO_SEND;
+      }
       *id = adis1650x::REQUEST;
       return preparePeriodicRequest(acs::SimpleSensorMode::NORMAL);
     }
@@ -87,12 +91,11 @@ ReturnValue_t GyrAdis1650XHandler::scanForReply(const uint8_t *start, size_t rem
       getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  *foundLen = remainingSize;
   if (remainingSize != sizeof(acs::Adis1650XReply)) {
-    *foundLen = remainingSize;
     return returnvalue::FAILED;
   }
   *foundId = adis1650x::REPLY;
-  *foundLen = remainingSize;
   if (internalState == InternalState::SHUTDOWN) {
     commandExecuted = true;
   }

mission/acs/GyrL3gCustomHandler.cpp

@@ -33,6 +33,7 @@ void GyrL3gCustomHandler::doStartUp() {
 void GyrL3gCustomHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
     internalState = InternalState::SHUTDOWN;
+    PoolReadGuard pg(&dataset);
     dataset.setValidity(false, true);
     commandExecuted = false;
   }
@@ -99,12 +100,11 @@ ReturnValue_t GyrL3gCustomHandler::scanForReply(const uint8_t *start, size_t len
   if (getMode() == _MODE_WAIT_OFF or getMode() == _MODE_WAIT_ON or getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  *foundLen = len;
   if (len != sizeof(acs::GyroL3gReply)) {
-    *foundLen = len;
     return returnvalue::FAILED;
   }
-  *foundId = l3gd20h::REPLY;
-  *foundLen = len;
+  *foundId = adis1650x::REPLY;
   if (internalState == InternalState::SHUTDOWN) {
     commandExecuted = true;
   }

mission/acs/ImtqHandler.cpp

@@ -151,19 +151,25 @@ void ImtqHandler::doStartUp() {
 }
 
 void ImtqHandler::doShutDown() {
-  updatePeriodicReply(false, imtq::cmdIds::REPLY_NO_TORQUE);
-  updatePeriodicReply(false, imtq::cmdIds::REPLY_WITH_TORQUE);
-  specialRequestActive = false;
-  firstReplyCycle = true;
-  internalState = InternalState::NONE;
-  commandExecuted = false;
-  statusSet.setValidity(false, true);
-  rawMtmNoTorque.setValidity(false, true);
-  rawMtmWithTorque.setValidity(false, true);
-  hkDatasetNoTorque.setValidity(false, true);
-  hkDatasetWithTorque.setValidity(false, true);
-  calMtmMeasurementSet.setValidity(false, true);
-  setMode(_MODE_POWER_DOWN);
+  if (internalState != InternalState::SHUTDOWN) {
+    commandExecuted = false;
+    internalState = InternalState::SHUTDOWN;
+  }
+  if (internalState == InternalState::SHUTDOWN and commandExecuted) {
+    updatePeriodicReply(false, imtq::cmdIds::REPLY_NO_TORQUE);
+    updatePeriodicReply(false, imtq::cmdIds::REPLY_WITH_TORQUE);
+    specialRequestActive = false;
+    firstReplyCycle = true;
+    internalState = InternalState::NONE;
+    commandExecuted = false;
+    statusSet.setValidity(false, true);
+    rawMtmNoTorque.setValidity(false, true);
+    rawMtmWithTorque.setValidity(false, true);
+    hkDatasetNoTorque.setValidity(false, true);
+    hkDatasetWithTorque.setValidity(false, true);
+    calMtmMeasurementSet.setValidity(false, true);
+    setMode(_MODE_POWER_DOWN);
+  }
 }
 
 ReturnValue_t ImtqHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
@@ -178,7 +184,7 @@ ReturnValue_t ImtqHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
     }
     default: {
       *id = imtq::cmdIds::REQUEST;
-      request.request = imtq::RequestType::DO_NOTHING;
+      request.requestType = imtq::RequestType::DO_NOTHING;
       request.specialRequest = imtq::SpecialRequest::NONE;
       expectedReply = DeviceHandlerIF::NO_COMMAND_ID;
       rawPacket = reinterpret_cast<uint8_t*>(&request);
@@ -190,7 +196,7 @@ ReturnValue_t ImtqHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
 }
 
 ReturnValue_t ImtqHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-  if (internalState == InternalState::STARTUP) {
+  if (internalState == InternalState::STARTUP or internalState == InternalState::SHUTDOWN) {
     *id = imtq::cmdIds::REQUEST;
     return buildCommandFromCommand(*id, nullptr, 0);
   }
@@ -201,7 +207,7 @@ ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
                                                    const uint8_t* commandData,
                                                    size_t commandDataLen) {
   auto genericSpecialRequest = [&](imtq::SpecialRequest specialRequest) {
-    request.request = imtq::RequestType::MEASURE_NO_ACTUATION;
+    request.requestType = imtq::RequestType::MEASURE_NO_ACTUATION;
     request.specialRequest = specialRequest;
     expectedReply = imtq::cmdIds::REPLY_NO_TORQUE;
     specialRequestActive = true;
@@ -238,9 +244,16 @@ ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
       return returnvalue::OK;
     }
     case (imtq::cmdIds::REQUEST): {
-      request.request = imtq::RequestType::MEASURE_NO_ACTUATION;
+      request.requestType = imtq::RequestType::MEASURE_NO_ACTUATION;
       request.specialRequest = imtq::SpecialRequest::NONE;
+      // 6 ms integration time instead of 10 ms.
+      request.integrationTimeSel = 2;
       expectedReply = imtq::cmdIds::REPLY_NO_TORQUE;
+      if (internalState == InternalState::SHUTDOWN) {
+        request.mode = acs::SimpleSensorMode::OFF;
+      } else {
+        request.mode = acs::SimpleSensorMode::NORMAL;
+      }
       rawPacket = reinterpret_cast<uint8_t*>(&request);
       rawPacketLen = sizeof(imtq::Request);
       return returnvalue::OK;
@@ -267,7 +280,7 @@ ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
       }
 
       expectedReply = imtq::cmdIds::REPLY_WITH_TORQUE;
-      request.request = imtq::RequestType::ACTUATE;
+      request.requestType = imtq::RequestType::ACTUATE;
       request.specialRequest = imtq::SpecialRequest::NONE;
       std::memcpy(request.dipoles, dipoleSet.dipoles.value, sizeof(request.dipoles));
       request.torqueDuration = dipoleSet.currentTorqueDurationMs.value;
@@ -309,6 +322,9 @@ ReturnValue_t ImtqHandler::scanForReply(const uint8_t* start, size_t remainingSi
   if (getMode() == _MODE_WAIT_OFF or getMode() == _MODE_WAIT_ON or getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  if (internalState == InternalState::SHUTDOWN) {
+    commandExecuted = true;
+  }
   if (remainingSize > 0) {
     *foundLen = remainingSize;
     *foundId = expectedReply;
@@ -779,9 +795,9 @@ ReturnValue_t ImtqHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(imtq::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 12.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
   poolManager.subscribeForDiagPeriodicPacket(

mission/acs/MgmLis3CustomHandler.cpp

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

mission/acs/MgmRm3100CustomHandler.cpp

@@ -33,6 +33,7 @@ void MgmRm3100CustomHandler::doStartUp() {
 void MgmRm3100CustomHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
     commandExecuted = false;
+    PoolReadGuard pg(&primaryDataset);
     primaryDataset.setValidity(false, true);
     internalState = InternalState::SHUTDOWN;
   }

mission/acs/RwHandler.cpp

@@ -4,6 +4,7 @@
 #include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
+#include <mission/acs/defs.h>
 
 #include "OBSWConfig.h"
 
@@ -23,40 +24,52 @@ RwHandler::RwHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCooki
   if (gpioComIF == nullptr) {
     sif::error << "RwHandler: Invalid gpio communication interface" << std::endl;
   }
+  currentRequest.rwIdx = rwIdx;
 }
+
 RwHandler::~RwHandler() {}
 
 void RwHandler::doStartUp() {
   internalState = InternalState::DEFAULT;
 
   if (gpioComIF->pullHigh(enableGpio) != returnvalue::OK) {
-    sif::debug << "RwHandler::doStartUp: Failed to pull enable gpio to high";
+    sif::error << "RW Handler " << rwIdx << ": Failed to pull ENABLE pin high for startup";
   }
+  currentRequest.mode = acs::SimpleSensorMode::NORMAL;
   updatePeriodicReply(true, rws::REPLY_ID);
   statusSet.setReportingEnabled(true);
   setMode(_MODE_TO_ON);
 }
 
 void RwHandler::doShutDown() {
-  if (gpioComIF->pullLow(enableGpio) != returnvalue::OK) {
-    sif::debug << "RwHandler::doStartUp: Failed to pull enable gpio to low";
+  if (internalState != InternalState::SHUTDOWN) {
+    internalState = InternalState::SHUTDOWN;
+    shutdownState = ShutdownState::SET_SPEED_ZERO;
+    offTransitionCountdown.resetTimer();
   }
-  internalState = InternalState::DEFAULT;
-  updatePeriodicReply(false, rws::REPLY_ID);
-  {
-    PoolReadGuard pg(&statusSet);
-    statusSet.currSpeed = 0.0;
-    statusSet.referenceSpeed = 0.0;
-    statusSet.state = 0;
-    statusSet.setValidity(false, true);
-    statusSet.setReportingEnabled(false);
+  if ((internalState == InternalState::SHUTDOWN) and
+      (shutdownState == ShutdownState::DONE or offTransitionCountdown.hasTimedOut())) {
+    if (gpioComIF->pullLow(enableGpio) != returnvalue::OK) {
+      sif::error << "RW Handler " << rwIdx << ": Failed to pull ENABLE pin low for shutdown";
+    }
+    updatePeriodicReply(false, rws::REPLY_ID);
+    {
+      PoolReadGuard pg(&statusSet);
+      statusSet.currSpeed = 0.0;
+      statusSet.referenceSpeed = 0.0;
+      statusSet.state = 0;
+      statusSet.setValidity(false, true);
+      statusSet.setReportingEnabled(false);
+    }
+    {
+      PoolReadGuard pg(&tmDataset);
+      tmDataset.setValidity(false, true);
+    }
+    internalState = InternalState::DEFAULT;
+    shutdownState = ShutdownState::NONE;
+    // The power switch is handled by the assembly, so we can go off here directly.
+    setMode(MODE_OFF);
   }
-  {
-    PoolReadGuard pg(&tmDataset);
-    tmDataset.setValidity(false, true);
-  }
-  // The power switch is handled by the assembly, so we can go off here directly.
-  setMode(MODE_OFF);
 }
 
 ReturnValue_t RwHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
@@ -73,6 +86,20 @@ ReturnValue_t RwHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
 }
 
 ReturnValue_t RwHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+  if (internalState == InternalState::SHUTDOWN) {
+    if (shutdownState == ShutdownState::SET_SPEED_ZERO) {
+      {
+        PoolReadGuard pg(&rwSpeedActuationSet);
+        rwSpeedActuationSet.setRwSpeed(0, 10);
+      }
+      *id = rws::REQUEST_ID;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    } else if (shutdownState == ShutdownState::STOP_POLLING) {
+      currentRequest.mode = acs::SimpleSensorMode::OFF;
+      *id = rws::REQUEST_ID;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+  }
   return NOTHING_TO_SEND;
 }
 
@@ -115,32 +142,36 @@ ReturnValue_t RwHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand
         return result;
       }
       // set speed flag.
-      commandBuffer[0] = true;
-      rawPacketLen = 1;
-      uint8_t* currentCmdBuf = commandBuffer + 1;
-      rwSpeedActuationSet.serialize(&currentCmdBuf, &rawPacketLen, sizeof(commandBuffer),
-                                    SerializeIF::Endianness::MACHINE);
-      commandBuffer[rawPacketLen++] = static_cast<uint8_t>(rws::SpecialRwRequest::REQUEST_NONE);
-      rawPacket = commandBuffer;
+      currentRequest.setSpeed = true;
+      rwSpeedActuationSet.getRwSpeed(currentRequest.currentRwSpeed, currentRequest.currentRampTime);
+      currentRequest.specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
+      rawPacket = reinterpret_cast<uint8_t*>(&currentRequest);
+      rawPacketLen = sizeof(rws::RwRequest);
       return returnvalue::OK;
     }
     case (rws::RESET_MCU): {
-      commandBuffer[0] = false;
-      commandBuffer[7] = static_cast<uint8_t>(rws::SpecialRwRequest::RESET_MCU);
+      currentRequest.setSpeed = false;
+      currentRequest.specialRequest = rws::SpecialRwRequest::RESET_MCU;
       internalState = InternalState::RESET_MCU;
+      rawPacket = reinterpret_cast<uint8_t*>(&currentRequest);
+      rawPacketLen = sizeof(rws::RwRequest);
       return returnvalue::OK;
     }
 
     case (rws::INIT_RW_CONTROLLER): {
-      commandBuffer[0] = false;
-      commandBuffer[7] = static_cast<uint8_t>(rws::SpecialRwRequest::INIT_RW_CONTROLLER);
+      currentRequest.setSpeed = false;
+      currentRequest.specialRequest = rws::SpecialRwRequest::INIT_RW_CONTROLLER;
       internalState = InternalState::INIT_RW_CONTROLLER;
+      rawPacket = reinterpret_cast<uint8_t*>(&currentRequest);
+      rawPacketLen = sizeof(rws::RwRequest);
       return returnvalue::OK;
     }
     case (rws::GET_TM): {
-      commandBuffer[0] = false;
-      commandBuffer[7] = static_cast<uint8_t>(rws::SpecialRwRequest::GET_TM);
+      currentRequest.setSpeed = false;
+      currentRequest.specialRequest = rws::SpecialRwRequest::GET_TM;
       internalState = InternalState::GET_TM;
+      rawPacket = reinterpret_cast<uint8_t*>(&currentRequest);
+      rawPacketLen = sizeof(rws::RwRequest);
       return returnvalue::OK;
     }
     default:
@@ -168,6 +199,9 @@ ReturnValue_t RwHandler::scanForReply(const uint8_t* start, size_t remainingSize
     *foundLen = remainingSize;
     *foundId = rws::REPLY_ID;
   }
+  if (internalState == InternalState::SHUTDOWN and shutdownState == ShutdownState::STOP_POLLING) {
+    shutdownState = ShutdownState::DONE;
+  }
   return returnvalue::OK;
 }
 
@@ -377,6 +411,12 @@ void RwHandler::handleGetRwStatusReply(const uint8_t* packet) {
 
   statusSet.setValidity(true, true);
 
+  if (internalState == InternalState::SHUTDOWN and std::abs(tmDataset.rwCurrSpeed.value) <= 2 and
+      shutdownState == ShutdownState::SET_SPEED_ZERO) {
+    // Finish transition to off.
+    shutdownState = ShutdownState::STOP_POLLING;
+  }
+
   if (statusSet.state == rws::STATE_ERROR) {
     // Trigger FDIR reaction, first recovery, then faulty if it doesnt fix the issue.
     triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT, statusSet.state.value, 0);

mission/acs/RwHandler.h

@@ -75,6 +75,8 @@ class RwHandler : public DeviceHandlerBase {
   GpioIF* gpioComIF = nullptr;
   gpioId_t enableGpio = gpio::NO_GPIO;
   bool debugMode = false;
+  Countdown offTransitionCountdown = Countdown(5000);
+  rws::RwRequest currentRequest;
 
   rws::StatusSet statusSet;
   rws::LastResetSatus lastResetStatusSet;
@@ -87,27 +89,16 @@ class RwHandler : public DeviceHandlerBase {
   PoolEntry<int32_t> rwSpeed = PoolEntry<int32_t>({0});
   PoolEntry<uint16_t> rampTime = PoolEntry<uint16_t>({10});
 
-  enum class InternalState {
-    DEFAULT,
-    GET_TM,
-    INIT_RW_CONTROLLER,
-    RESET_MCU,
-    // GET_RESET_STATUS,
-    // CLEAR_RESET_STATUS,
-    // READ_TEMPERATURE,
-    // SET_SPEED,
-    // GET_RW_SATUS
-  };
+  enum class InternalState { DEFAULT, GET_TM, INIT_RW_CONTROLLER, RESET_MCU, SHUTDOWN };
+  enum class ShutdownState {
+    NONE,
+    SET_SPEED_ZERO,
+    STOP_POLLING,
+    DONE,
+  } shutdownState = ShutdownState::NONE;
 
   InternalState internalState = InternalState::DEFAULT;
 
-  /**
-   * @brief   This function can be used to build commands which do not contain any data apart
-   *          from the command id and the CRC.
-   * @param commandId The command id of the command to build.
-   */
-  // void prepareSimpleCommand(DeviceCommandId_t id);
-
   /**
    * @brief   This function checks if the receiced speed and ramp time to set are in a valid
    *          range.
@@ -115,13 +106,6 @@ class RwHandler : public DeviceHandlerBase {
    */
   ReturnValue_t checkSpeedAndRampTime();
 
-  /**
-   * @brief   This function prepares the set speed command from the dataSet received with
-   *          an action message or set in the software.
-   * @return  returnvalue::OK if successful, otherwise error code.
-   */
-  // ReturnValue_t prepareSetSpeedCmd();
-
   /**
    * @brief   This function writes the last reset status retrieved with the get last reset status
    *          command into the reset status dataset.

mission/acs/SusHandler.cpp

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

mission/acs/acsBoardPolling.h

@@ -1,13 +1,13 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_ACSPOLLING_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_ACSPOLLING_H_
 
+#include <mission/acs/defs.h>
+
 #include "fsfw/thermal/tcsDefinitions.h"
 #include "gyroAdisHelpers.h"
 
 namespace acs {
 
-enum SimpleSensorMode { NORMAL = 0, OFF = 1 };
-
 struct Adis1650XRequest {
   SimpleSensorMode mode;
   adis1650x::Type type;

mission/acs/defs.h

@@ -6,7 +6,9 @@
 
 namespace acs {
 
-// These modes are the submodes of the ACS controller and the modes of the ACS subsystem.
+enum class SimpleSensorMode { NORMAL = 0, OFF = 1 };
+
+// These modes are the modes of the ACS controller and of the ACS subsystem.
 enum AcsMode : Mode_t {
   OFF = HasModesIF::MODE_OFF,
   SAFE = 10,
@@ -19,23 +21,40 @@ enum AcsMode : Mode_t {
 
 enum SafeSubmode : Submode_t { DEFAULT = 0, DETUMBLE = 1 };
 
-// static constexpr uint8_t ACS_SYSTEM_DETUMBLE_SUBMODE = 1;
+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,
+  SAFECTRL_DETUMBLE_FULL = 20,
+  SAFECTRL_DETUMBLE_DETERIORATED = 21,
+};
 
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::ACS_SUBSYSTEM;
-//!< The limits for the rotation in safe mode were violated.
-static const Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);
-//!< The system has recovered from a safe rate rotation violation.
+//! [EXPORT] : [COMMENT] The limits for the rotation in safe mode were violated.
+static constexpr Event SAFE_RATE_VIOLATION = MAKE_EVENT(0, severity::MEDIUM);
+//! [EXPORT] : [COMMENT] The system has recovered from a safe rate rotation violation.
 static constexpr Event SAFE_RATE_RECOVERY = MAKE_EVENT(1, severity::MEDIUM);
-//!< Multiple RWs are invalid, not commandable and therefore higher ACS modes cannot be maintained.
+//! [EXPORT] : [COMMENT] Multiple RWs are invalid, uncommandable and therefore higher ACS modes
+//! cannot be maintained.
 static constexpr Event MULTIPLE_RW_INVALID = MAKE_EVENT(2, severity::HIGH);
-//!< MEKF was not able to compute a solution.
+//! [EXPORT] : [COMMENT] MEKF was not able to compute a solution.
+//! P1: MEKF state on exit
 static constexpr Event MEKF_INVALID_INFO = MAKE_EVENT(3, severity::INFO);
-//!< MEKF is able to compute a solution again.
+//! [EXPORT] : [COMMENT] MEKF is able to compute a solution again.
 static constexpr Event MEKF_RECOVERY = MAKE_EVENT(4, severity::INFO);
-//!< MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.
-static constexpr Event MEKF_INVALID_MODE_VIOLATION = MAKE_EVENT(5, severity::HIGH);
-//!< The ACS safe mode controller was not able to compute a solution and has failed.
-static constexpr Event SAFE_MODE_CONTROLLER_FAILURE = MAKE_EVENT(6, severity::HIGH);
+//! [EXPORT] : [COMMENT] MEKF performed an automatic reset after detection of nonfinite values.
+static constexpr Event MEKF_AUTOMATIC_RESET = MAKE_EVENT(5, severity::INFO);
+//! [EXPORT] : [COMMENT] MEKF was not able to compute a solution during any pointing ACS mode for a
+//! prolonged time.
+static constexpr Event MEKF_INVALID_MODE_VIOLATION = MAKE_EVENT(6, severity::HIGH);
+//! [EXPORT] : [COMMENT] 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
+static constexpr Event SAFE_MODE_CONTROLLER_FAILURE = MAKE_EVENT(7, severity::HIGH);
 
 extern const char* getModeStr(AcsMode mode);
 

mission/acs/imtqHelpers.cpp

@@ -1,5 +1,26 @@
 #include "imtqHelpers.h"
 
+uint16_t imtq::integrationTimeFromSelectValue(uint8_t value) {
+  switch (value) {
+    case (0):
+      return 2;
+    case (1):
+      return 3;
+    case (2):
+      return 6;
+    case (3):
+      return 10;
+    case (4):
+      return 20;
+    case (5):
+      return 40;
+    case (6):
+      return 80;
+    default:
+      return 10;
+  }
+}
+
 size_t imtq::getReplySize(CC::CC cc, size_t* optSecondSize) {
   switch (cc) {
     // Software reset is a bit special and can also cause a I2C NAK because

mission/acs/imtqHelpers.h

@@ -5,6 +5,7 @@
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <mission/acs/defs.h>
 
 class ImtqHandler;
 
@@ -13,6 +14,8 @@ class ImtqHandler;
 
 namespace imtq {
 
+uint16_t integrationTimeFromSelectValue(uint8_t value);
+
 enum class RequestType : uint8_t { MEASURE_NO_ACTUATION, ACTUATE, DO_NOTHING };
 
 enum class SpecialRequest : uint8_t {
@@ -27,7 +30,8 @@ enum class SpecialRequest : uint8_t {
 };
 
 struct Request {
-  imtq::RequestType request = imtq::RequestType::MEASURE_NO_ACTUATION;
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  imtq::RequestType requestType = imtq::RequestType::MEASURE_NO_ACTUATION;
   imtq::SpecialRequest specialRequest = imtq::SpecialRequest::NONE;
   uint8_t integrationTimeSel = 3;
   int16_t dipoles[3]{};
@@ -57,9 +61,10 @@ static const ReturnValue_t CC_UNAVAILABLE = MAKE_RETURN_CODE(5);
 static const ReturnValue_t INTERNAL_PROCESSING_ERROR = MAKE_RETURN_CODE(6);
 static const ReturnValue_t REJECTED_WITHOUT_REASON = MAKE_RETURN_CODE(7);
 static const ReturnValue_t CMD_ERR_UNKNOWN = MAKE_RETURN_CODE(8);
+static constexpr ReturnValue_t STARTUP_CFG_ERROR = MAKE_RETURN_CODE(9);
 //! [EXPORT] : [COMMENT] The status reply to a self test command was received but no self test
 //! command has been sent. This should normally never happen.
-static const ReturnValue_t UNEXPECTED_SELF_TEST_REPLY = MAKE_RETURN_CODE(0xA7);
+static const ReturnValue_t UNEXPECTED_SELF_TEST_REPLY = MAKE_RETURN_CODE(10);
 
 namespace cmdIds {
 
@@ -162,6 +167,13 @@ enum CC : uint8_t {
 
 }  // namespace CC
 
+namespace param {
+
+static constexpr uint16_t SEL_MTM = 0x2002;
+static constexpr uint16_t INTEGRATION_TIME_SELECT = 0x2003;
+
+}  // namespace param
+
 size_t getReplySize(CC::CC cc, size_t* optSecondSize = nullptr);
 
 namespace mode {

mission/acs/rwHelpers.h

@@ -4,6 +4,7 @@
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <mission/acs/defs.h>
 
 #include "eive/resultClassIds.h"
 #include "events/subsystemIdRanges.h"
@@ -36,6 +37,15 @@ enum class SpecialRwRequest : uint8_t {
   NUM_REQUESTS
 };
 
+struct RwRequest {
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  bool setSpeed = true;
+  int32_t currentRwSpeed = 0;
+  uint16_t currentRampTime = 0;
+  rws::SpecialRwRequest specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
+  uint8_t rwIdx = 0;
+};
+
 static const uint8_t INTERFACE_ID = CLASS_ID::RW_HANDLER;
 
 static const ReturnValue_t SPI_WRITE_FAILURE = MAKE_RETURN_CODE(0xB0);

mission/acs/str/ArcsecDatalinkLayer.cpp

@@ -1,6 +1,11 @@
-#include <mission/acs/str/ArcsecDatalinkLayer.h>
+#include "ArcsecDatalinkLayer.h"
 
-ArcsecDatalinkLayer::ArcsecDatalinkLayer() : decodeRingBuf(BUFFER_LENGTHS, true) { slipInit(); }
+extern "C" {
+#include <wire/common/SLIP.h>
+#include <wire/common/misc.h>
+}
+
+ArcsecDatalinkLayer::ArcsecDatalinkLayer() : decodeRingBuf(BUFFER_LENGTHS, true) {}
 
 ArcsecDatalinkLayer::~ArcsecDatalinkLayer() {}
 
@@ -11,38 +16,50 @@ ReturnValue_t ArcsecDatalinkLayer::checkRingBufForFrame(const uint8_t** decodedF
     return DEC_IN_PROGRESS;
   }
   decodeRingBuf.readData(rxAnalysisBuffer, currentLen);
+
+  bool startFound = false;
+  size_t startIdx = 0;
   for (size_t idx = 0; idx < currentLen; idx++) {
-    enum arc_dec_result decResult =
-        arc_transport_decode_body(rxAnalysisBuffer[idx], &slipInfo, decodedRxFrame, &rxFrameSize);
-    switch (decResult) {
-      case ARC_DEC_INPROGRESS: {
-        break;
-      }
-      case ARC_DEC_ERROR_FRAME_SHORT: {
-        decodeRingBuf.deleteData(idx);
-        return REPLY_TOO_SHORT;
-      }
-      case ARC_DEC_ERROR_CHECKSUM:
-        decodeRingBuf.deleteData(idx);
-        return CRC_FAILURE;
-      case ARC_DEC_ASYNC:
-      case ARC_DEC_SYNC: {
-        // Reset length of SLIP struct for next frame
-        slipInfo.length = 0;
+    if (rxAnalysisBuffer[idx] != SLIP_START_AND_END) {
+      continue;
+    }
+    if (not startFound) {
+      startFound = true;
+      startIdx = idx;
+      continue;
+    }
+    // Now we can try decoding the whole frame.
+    size_t encodedDataSize = 0;
+    slip_error_t slipError =
+        slip_decode_frame(decodedRxFrame, &rxFrameSize, rxAnalysisBuffer + startIdx,
+                          idx - startIdx + 1, &encodedDataSize, ARC_DEF_SAGITTA_SLIP_ID);
+    decodeRingBuf.deleteData(idx + 1);
+    switch (slipError) {
+      case (SLIP_OK): {
         if (decodedFrame != nullptr) {
           *decodedFrame = decodedRxFrame;
         }
         frameLen = rxFrameSize;
-        decodeRingBuf.deleteData(idx);
         return returnvalue::OK;
       }
-      default:
-        sif::debug << "ArcsecDatalinkLayer::decodeFrame: Unknown result code" << std::endl;
-        break;
+      case (SLIP_BAD_CRC): {
+        return CRC_FAILURE;
+      }
+      case (SLIP_OVERFLOW): {
+        return SLIP_OVERFLOW_RETVAL;
+      }
+      // Should not happen, we searched for start and end marker..
+      case (SLIP_NO_END): {
         return returnvalue::FAILED;
+      }
+      case (SLIP_ID_MISMATCH): {
+        return SLIP_ID_MISSMATCH_RETVAL;
+      }
+      default: {
+        return returnvalue::FAILED;
+      }
     }
   }
-  decodeRingBuf.deleteData(currentLen);
   return DEC_IN_PROGRESS;
 }
 
@@ -55,18 +72,11 @@ ReturnValue_t ArcsecDatalinkLayer::feedData(const uint8_t* rawData, size_t rawDa
   return decodeRingBuf.writeData(rawData, rawDataLen);
 }
 
-void ArcsecDatalinkLayer::reset() {
-  slipInit();
-  decodeRingBuf.clear();
-}
-
-void ArcsecDatalinkLayer::slipInit() {
-  slip_decode_init(rxBufferArc, sizeof(rxBufferArc), &slipInfo);
-}
+void ArcsecDatalinkLayer::reset() { decodeRingBuf.clear(); }
 
 void ArcsecDatalinkLayer::encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame,
                                       size_t& size) {
-  arc_transport_encode_body(data, length, txEncoded, &size);
+  slip_encode_frame(data, length, txEncoded, &size, ARC_DEF_SAGITTA_SLIP_ID);
   if (txFrame != nullptr) {
     *txFrame = txEncoded;
   }

mission/acs/str/ArcsecDatalinkLayer.h

@@ -5,10 +5,13 @@
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <mission/acs/str/strHelpers.h>
 
-#include "arcsec/common/misc.h"
 #include "eive/resultClassIds.h"
 #include "fsfw/returnvalues/returnvalue.h"
 
+extern "C" {
+#include <wire/common/SLIP.h>
+}
+
 /**
  * @brief   Helper class to handle the datalinklayer of replies from the star tracker of arcsec.
  */
@@ -22,6 +25,8 @@ class ArcsecDatalinkLayer {
   static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xA1);
   //! [EXPORT] : [COMMENT] Detected CRC failure in received frame
   static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA2);
+  static const ReturnValue_t SLIP_OVERFLOW_RETVAL = MAKE_RETURN_CODE(0xA3);
+  static const ReturnValue_t SLIP_ID_MISSMATCH_RETVAL = MAKE_RETURN_CODE(0xA4);
 
   static const uint8_t STATUS_OK = 0;
 
@@ -74,7 +79,7 @@ class ArcsecDatalinkLayer {
   // Decoded frame will be copied to this buffer
   uint8_t decodedRxFrame[startracker::MAX_FRAME_SIZE];
   // Size of decoded frame
-  uint32_t rxFrameSize = 0;
+  size_t rxFrameSize = 0;
 
   // Buffer where encoded frames will be stored. First byte of encoded frame represents type of
   // reply
@@ -82,7 +87,7 @@ class ArcsecDatalinkLayer {
   // Size of encoded frame
   uint32_t txFrameSize = 0;
 
-  slip_decode_state slipInfo;
+  // slip_decode_state slipInfo;
 
   void slipInit();
 };