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

Reviewed-on: #705

.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

CHANGELOG.md

@@ -16,6 +16,384 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v4.0.1] 2023-06-24
+
+## Fixed
+
+- `PusLiveDemux` packet demultiplexing bugfix where the demultiplexing did not work when there was
+  only one destination available.
+
+# [v4.0.0] 2023-06-22
+
+- `eive-tmtc` version v5.0.0
+- `q7s-package` version v3.1.1
+
+## Fixed
+
+- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
+- TCS fixes: Set temperature values to invalid value for MAX31865 RTD handler, SUS handler
+  and STR handler. Also set dataset to invakid for RTD handler.
+- Fixed H parameter in SUS converter from 1 mm to 2.5 mm.
+
+## Changed
+
+- Removed PTME busy/ready signals. Those were not used anyway because register reads are used now.
+- APB bus access busy checking is not done anymore as this is performed by the bus itself now.
+- Core controller will now announce version and image information event in addition to reboot
+  event in the `inititalize` function.
+- Core controller will now try to request and announce the firmware version in addition to the
+  OBSW version as well.
+- Added core controller action to read reboot mechansm information
+- GNSS reset pin will now only be asserted for 5 ms instead of 100 ms.
+
+## Added
+
+- Added PL I2C reset pin. It is not used/connected for now but could be used for FDIR procedures to
+  restore the PL I2C.
+- Core controller now announces firmware version as well when requesting a version info event
+
+# [v3.3.0] 2023-06-21
+
+Like v3.2.0 but without the custom FM changes related to VC0.
+
+# [v3.2.0] 2023-06-21
+
+## Fixed
+
+- Fix sun vector calculation
+- SUS total vector was not reset to being a zero vector during eclipse due to a wrong memcpy
+  length.
+
+## Changed
+
+- Reverted all changes related to VC0 handling to avoid FM bug possibly related to FPGA bug.
+
+# [v3.1.1] 2023-06-14
+
+## Fixed
+
+- TMP1075 bugfix where negative temperatures could not be measured because of a two's-complement
+  conversion bug.
+
+# [v3.1.0] 2023-06-14
+
+- `eive-tmtc` version v4.1.0
+
+## Fixed
+
+- TCS heater switch enumeration naming was old/wrong and was not updated in sync with the object ID
+  update. This lead to the TCS controller commanding the wrong heaters.
+
+## Changed
+
+- Increase number of allowed parallel HK commands to 16
+
+## Added
+
+- Added `CONFIG_SET`, `MAN_HEATER_ON` and `MAN_HEATER_OFF` support for the BPX battery handler
+
+# [v3.0.0] 2023-06-11
+
+- `eive-tmtc` version v4.0.0
+
+## Changed
+
+- Adapt EM configuration to include all GomSpace PCDU devices except the ACU. For the ACU
+  (which broke), a dummy will still be used.
+- Event Manager queue depth is configurable now.
+- Do not construct and schedule broken TMP1075 device anymore.
+- Do not track payload modes in system mode tables.
+- ACS modes derived from system modes.
+- The CMake build generator will now search for the cross-compiler binaries in the environmental
+  variable named `CROSS_COMPILE_BIN_PATH` first when setting up the build system. This prevents
+  CMake from selecting wrong cross-compilers if multiple cross-compilers with the same name are used
+  on the same system.
+- Add ACS board for EM by default now.
+- Add support for MPSoC HK packet.
+- Add support for MPSoC Flash Directory Content Report.
+- Dynamically enable and disable HK packets for MPSoC on `ON` and `OFF` commands.
+- Add support for MPSoC Flash Directory Content Report.
+- Larger allowed path and file sizes for STR and PLOC MPSoC modules.
+- More robust MPSoC flash read and write command data handling.
+- Increase frequency of payload handlers from 0.8 seconds to 0.5 seconds.
+- Disable missed deadlines per default. Not useful in orbit, and triggers all the time on the EM
+  build after a number of subsequent runs, without any apparent reason (deadlines are not actually
+  missed, thread usage displayed is nominal)
+- TM store dumpes will not be cancelled anymore if the transmitter is off. The dump can be cancelled
+  with an OFF command, and the PTME is perfectly capable of dumping without the transmitter being
+  on.
+- Transmitter state is not taken into account anymore for writing into the PTME. The PTME should
+  be perfectly capable of generating a valid CADU, even when the transmitter is not ON for any
+  reason.
+- OFF mode is ignores in TM store for determining whether a store will be written. The modes will
+  only be used to cancel a transfer.
+- Handling of multiple RWs in the ACS Controller is improved and can be changed by parameter
+  commands.
+- The Directory Listing direct dumper now has a state machine to stagger the directory listing dump.
+  This is required because very large dumps will overload the queue capacities in the framework.
+- The PUS Service 8 now has larger queue sizes to handle more action replies. The PUS Service 1
+  also has a larger queue size to handle a lot of step replies now.
+- Moved PDU `vcc` and `vbat` variable from auxiliary dataset to core dataset.
+- Tweak TCP/IP configuration: Only the TCP server will be included on the EM. For the FM, no
+  TCP/IP servers will be included by default.
+
+## Added
+
+- Add the remaining system modes.
+- PLOC MPSoC flash read command working.
+- BPX battery handler is added for EM by default.
+- ACU dummy HK sets
+- IMTQ HK sets
+- IMTQ dummy now handles power switch
+- Added some new ACS parameters
+- Enabled decimation filter for the ADIS GYRs
+- Enabled second low-pass filter for L3GD20H GYRs
+
+## Fixed
+
+- CFDP low level protocol bugfix. Requires `fsfw` update and `tmtc` update.
+- Compile fix if SCEX is compiled for the EM.
+- Set up Rad Sensor chip select even for EM to avoid SPI bus issues.
+- Correct ADIS Gyroscope type configuration for the EM, where the 16507 type is used instead of the
+  16505 type.
+- Host build is working again. Added reduced live TM helper which schedules the PUS and CFDP
+  funnel.
+- PLOC Supervisor handler now has a power switcher assigned to make PLOC power switching work
+  without an additional PCDU power switch command.
+- The PLOC Supervisor handler now waits for the replies to the `SET_TIME` command to verify working
+  communication.
+- The PLOC MPSoC now waits 10 cycles before going to on. These wait cycles are necessary because
+  the MPSoC is not ready to process commands without this additional boot time.
+- Fixed correction for `GPS Altitude` in case the sensor data is out of the expected bonds.
+- PLOC MPSoC special communication is now scheduled, which allows flash read and flash write
+  commands to work.
+- Fixed the MPSoC flash write command.
+- Added missing ACS parameter.
+- HK TM store: The HK store dump success event was triggered for cancelled HK dumps.
+- When a PUS parsing error occured while parsing a TM store file, the dump completion procedure
+  was always executed.
+- Some smaller logic fixes in the TM store base class
+- Fixed usage of C `abs` instead of C++ `std::abs`, which results in MTQ commands not being
+  scaled correctly between 1Am² and 0.2Am².
+- TCS Heater Handler: Always trigger mode event if a heater goes `OFF` or `ON`. This event might
+  soon replace the `HEATER_WENT_ON` and `HEATER_WENT_OFF` events.
+- Prevent spam of TCS controller heater unavailability event if all heaters are in external control.
+- TCS heater switch info set contained invalid values because of a faulty `memcpy` in the TCS
+  controller. There is not crash risk but the heater states were invalid.
+- STR datasets were not set to invalid on shutdown.
+- Fixed usage of quaternion valid flag, which does not actually represent the validity of the
+  quaternion.
+- Various fixes for the pointing modes of the `ACS Controller`. All modes should work now as
+  intended.
+- The variance for the ADIS GYRs now represents the used `-3` version and not the `-1` version
+- CFDP funnel did not route packets to live channel VC0
+
+# [v2.0.5] 2023-05-11
+
+- The dual lane assembly transition failed handler started new transitions towards the current mode
+  instead of the target mode. This means that if the dual lane assembly never reached the initial
+  submode (e.g. mode normal and submode dual side), it will transition back to the current mode,
+  which miht be `MODE_OFF`. Furthermore, this can lead to invalid internal states, so the subsequent
+  recovery handling becomes stuck in the custom recovery sequence when swichting power back on.
+- The dual lane custom recovery handling was adapted to always perform proper power switch handling
+  irrespective of current or target modes.
+
+# [v2.0.4] 2023-04-19
+
+## Fixed
+
+- The dual lane assembly datasets were not marked invalid properly 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

CMakeLists.txt

@@ -9,8 +9,8 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 43)
+set(OBSW_VERSION_MAJOR 4)
+set(OBSW_VERSION_MINOR 0)
 set(OBSW_VERSION_REVISION 1)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -79,12 +79,19 @@ else()
   set(INIT_VAL 1)
   set(OBSW_STAR_TRACKER_GROUND_CONFIG 0)
 endif()
+
+set(OBSW_ADD_TMTC_TCP_SERVER
+    ${OBSW_Q7S_EM}
+    CACHE STRING "Add TCP TMTC Server")
+set(OBSW_ADD_TMTC_UDP_SERVER
+    0
+    CACHE STRING "Add UDP TMTC Server")
 set(OBSW_ADD_MGT
     ${INIT_VAL}
     CACHE STRING "Add MGT module")
 set(OBSW_ADD_BPX_BATTERY_HANDLER
-    ${INIT_VAL}
-    CACHE STRING "Add MGT module")
+    1
+    CACHE STRING "Add BPX battery module")
 set(OBSW_ADD_STAR_TRACKER
     ${INIT_VAL}
     CACHE STRING "Add Startracker module")
@@ -94,6 +101,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")
@@ -143,8 +153,11 @@ set(OBSW_ADD_TMP_DEVICES
     ${INIT_VAL}
     CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
-    ${INIT_VAL}
+    1
     CACHE STRING "Add GomSpace PCDU modules")
+set(OBSW_ADD_GOMSPACE_ACU
+    ${INIT_VAL}
+    CACHE STRING "Add GomSpace ACU submodule")
 set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")
@@ -220,7 +233,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)

README.md

@@ -99,11 +99,21 @@ When using Windows, run theses steps in MSYS2.
    git submodule update --init
    ```
 
-3. Ensure that the cross-compiler is working with `arm-linux-gnueabihf-gcc --version` and that
+3. Create two system variables to pass the system root path and the cross-compiler path to the
+   build system. You only need to do this once when setting up the build system.
+   Example for Unix:
+
+   ```sh
+   export CROSS_COMPILE_BIN_PATH=<absolutePathToCrossCompilerBinPath>
+   export ZYNQ_7020_SYSROOT=<absolutePathToSysroot>
+   ```
+
+4. Ensure that the cross-compiler is working with
+   `${CROSS_COMPILE_BIN_PATH}/arm-linux-gnueabihf-gcc --version` and that
    the sysroot environmental variables have been set like specified in the
    [root filesystem chapter](#sysroot).
 
-4. Run the CMake configuration to create the build system in a `build-Debug-Q7S` folder.
+5. Run the CMake configuration to create the build system in a `build-Debug-Q7S` folder.
    Add `-G "MinGW Makefiles` in MinGW64 on Windows.
 
    ```sh
@@ -112,7 +122,7 @@ When using Windows, run theses steps in MSYS2.
    cmake --build . -j
    ```
 
-   You can also use provided shell scripts to perform these commands.
+   Please note that you can also use provided shell scripts to perform these commands.
    ```sh
    cp scripts/q7s-env.sh ..
    cp scripts/q7s-env-em.sh ..
@@ -144,7 +154,7 @@ When using Windows, run theses steps in MSYS2.
    There are also different values for `-DTGT_BSP` to build for the Raspberry Pi
    or the Beagle Bone Black: `arm/raspberrypi` and `arm/beagleboneblack`.
 
-5. Build the software with
+6. Build the software with
 
    ```sh
    cd cmake-build-debug-q7s

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

@@ -39,7 +39,7 @@
 #include "devices/gpioIds.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "linux/payload/PlocMpsocHandler.h"
-#include "linux/payload/PlocMpsocHelper.h"
+#include "linux/payload/PlocMpsocSpecialComHelper.h"
 #include "linux/payload/PlocSupervisorHandler.h"
 #include "linux/payload/PlocSupvUartMan.h"
 #include "test/gpio/DummyGpioIF.h"
@@ -62,10 +62,15 @@ void ObjectFactory::produce(void* args) {
   StorageManagerIF* tmStore;
   StorageManagerIF* ipcStore;
   PersistentTmStores persistentStores;
+  bool enableHkSets = false;
+#if OBSW_ENABLE_PERIODIC_HK == 1
+  enableHkSets = true;
+#endif
   auto sdcMan = new DummySdCardManager("/tmp");
   ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores);
+                                       &tmStore, persistentStores, 120);
 
+  new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
   auto* dummyGpioIF = new DummyGpioIF();
   auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
   std::vector<ReturnValue_t> switcherList;
@@ -81,8 +86,8 @@ void ObjectFactory::produce(void* args) {
   auto mpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER, mpscoDev, uart::PLOC_MPSOC_BAUD,
                                     mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
-  auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-  new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
+  auto plocMpsocHelper = new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER);
+  new PlocMpsocHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
                        plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF),
                        objects::PLOC_SUPERVISOR_HANDLER);
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
@@ -100,7 +105,7 @@ void ObjectFactory::produce(void* args) {
 #endif
 
   dummy::DummyCfg cfg;
-  dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF);
+  dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF, enableHkSets);
 
   HeaterHandler* heaterHandler = nullptr;
   // new ThermalController(objects::THERMAL_CONTROLLER);

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 284 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-04 13:59:07
+ * Generated on: 2023-06-21 19:01:02
  */
 #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";
@@ -193,6 +197,10 @@ const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
 const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
 const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
 const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
+const char *MPSOC_FLASH_READ_PACKET_ERROR_STRING = "MPSOC_FLASH_READ_PACKET_ERROR";
+const char *MPSOC_FLASH_READ_FAILED_STRING = "MPSOC_FLASH_READ_FAILED";
+const char *MPSOC_FLASH_READ_SUCCESSFUL_STRING = "MPSOC_FLASH_READ_SUCCESSFUL";
+const char *MPSOC_READ_TIMEOUT_STRING = "MPSOC_READ_TIMEOUT";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@@ -266,7 +274,10 @@ 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 *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -274,6 +285,7 @@ const char *OBC_OVERHEATING_STRING = "OBC_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 +489,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 +617,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):
@@ -668,6 +688,14 @@ const char *translateEvents(Event event) {
       return MPSOC_TM_SIZE_ERROR_STRING;
     case (12613):
       return MPSOC_TM_CRC_MISSMATCH_STRING;
+    case (12614):
+      return MPSOC_FLASH_READ_PACKET_ERROR_STRING;
+    case (12615):
+      return MPSOC_FLASH_READ_FAILED_STRING;
+    case (12616):
+      return MPSOC_FLASH_READ_SUCCESSFUL_STRING;
+    case (12617):
+      return MPSOC_READ_TIMEOUT_STRING;
     case (12700):
       return TRANSITION_BACK_TO_OFF_STRING;
     case (12701):
@@ -815,7 +843,13 @@ 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 (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -830,6 +864,8 @@ const char *translateEvents(Event event) {
       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

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

bsp_hosted/scheduling.cpp

@@ -59,19 +59,15 @@ void scheduling::initTasks() {
       "DIST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding CCSDS distributor failed" << std::endl;
+    sif::error << "Adding CCSDS distributor failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding PUS distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
-    sif::error << "adding TM funnel failed" << std::endl;
+    sif::error << "Adding PUS distributor failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding CFDP distributor failed" << std::endl;
+    sif::error << "Adding CFDP distributor failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
   if (result != returnvalue::OK) {
@@ -95,6 +91,13 @@ void scheduling::initTasks() {
     sif::error << "Add component UDP Polling failed" << std::endl;
   }
 
+  PeriodicTaskIF* liveTmTask = factory->createPeriodicTask(
+      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, nullptr, &RR_SCHEDULING);
+  result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
+  }
+
   PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
       "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
@@ -149,9 +152,8 @@ void scheduling::initTasks() {
       "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
   result = thermalTask->addComponent(objects::CORE_CONTROLLER);
   if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+    scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
   }
-
   result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
@@ -218,6 +220,7 @@ void scheduling::initTasks() {
   tmtcDistributor->startTask();
   udpPollingTask->startTask();
   tcpPollingTask->startTask();
+  liveTmTask->startTask();
 
   pusHighPrio->startTask();
   pusMedPrio->startTask();

bsp_q7s/OBSWConfig.h.in

@@ -22,6 +22,9 @@
 #define OBSW_COMMAND_SAFE_MODE_AT_STARTUP           1
 
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
+// This define is necessary because the EM setup has the P60 dock module, but no ACU on the P60
+// module because it broke.
+#define OBSW_ADD_GOMSPACE_ACU                       @OBSW_ADD_GOMSPACE_ACU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
@@ -43,6 +46,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
@@ -61,12 +67,12 @@
 // because UDP packets are not allowed in the VPN
 // This will cause the OBSW to initialize the TMTC bridge responsible for exchanging data with the
 // CCSDS IP Cores. 
-#define OBSW_ADD_TMTC_TCP_SERVER                    1
-#define OBSW_ADD_TMTC_UDP_SERVER                    1
+#define OBSW_ADD_TMTC_TCP_SERVER                    @OBSW_ADD_TMTC_TCP_SERVER@
+#define OBSW_ADD_TMTC_UDP_SERVER                    @OBSW_ADD_TMTC_UDP_SERVER@
 
 // Can be used to switch device to NORMAL mode immediately
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    0
-#define OBSW_PRINT_MISSED_DEADLINES                 1
+#define OBSW_PRINT_MISSED_DEADLINES                 0
 
 #define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             @OBSW_STAR_TRACKER_GROUND_CONFIG@

bsp_q7s/boardconfig/busConf.h

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

bsp_q7s/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

@@ -4,6 +4,7 @@
 #include <fsfw/filesystem/HasFileSystemIF.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 
 #include "commonConfig.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -22,6 +23,7 @@
 #include <algorithm>
 #include <filesystem>
 
+#include "bsp_q7s/boardconfig/busConf.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "bsp_q7s/xadc/Xadc.h"
@@ -31,8 +33,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 +42,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 +56,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 +90,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 +114,15 @@ 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 (dumpContext.active) {
+    dirListingDumpHandler();
   }
+
   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 +140,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 +163,16 @@ 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);
+  announceCurrentImageInfo();
+  announceVersionInfo();
   EventManagerIF *eventManager =
       ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (eventManager == nullptr or eventQueue == nullptr) {
@@ -180,6 +189,14 @@ ReturnValue_t CoreController::initialize() {
   if (result != returnvalue::OK) {
     sif::warning << "Subscribing for GPS GPS_FIX_CHANGE event failed" << std::endl;
   }
+
+  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
+  result = sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
+  if (result != returnvalue::OK) {
+    // TODO: This might be a reason to switch to another image..
+    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
+    return ObjectManager::CHILD_INIT_FAILED;
+  }
   return returnvalue::OK;
 }
 
@@ -202,21 +219,10 @@ 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) |
-                    (common::OBSW_VERSION_REVISION << 8);
-      uint32_t p2 = 0;
-      if (strcmp("", common::OBSW_VERSION_CST_GIT_SHA1) != 0) {
-        p1 |= 1;
-        auto shaAsStr = std::string(common::OBSW_VERSION_CST_GIT_SHA1);
-        size_t posDash = shaAsStr.find("-");
-        auto gitHash = shaAsStr.substr(posDash + 2, 4);
-        // Only copy first 4 letters of git hash
-        memcpy(&p2, gitHash.c_str(), 4);
-      }
-
-      triggerEvent(VERSION_INFO, p1, p2);
+      announceVersionInfo();
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (ANNOUNCE_BOOT_COUNTS): {
@@ -224,18 +230,98 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (ANNOUNCE_CURRENT_IMAGE): {
-      triggerEvent(CURRENT_IMAGE_INFO, CURRENT_CHIP, CURRENT_COPY);
+      announceCurrentImageInfo();
       return HasActionsIF::EXECUTION_FINISHED;
     }
     case (LIST_DIRECTORY_INTO_FILE): {
       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.isForceOptSet()) {
+        oss << "-f ";
+      }
+      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;
       }
       std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
-      // Disable the reboot file mechanism
       parseRebootFile(path, rebootFile);
       if (data[0] == 0) {
         rebootFile.enabled = false;
@@ -248,6 +334,16 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       }
       return HasActionsIF::EXECUTION_FINISHED;
     }
+    case (READ_REBOOT_MECHANISM_INFO): {
+      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
+      parseRebootFile(path, rebootFile);
+      RebootMechanismPacket packet(rebootFile);
+      ReturnValue_t result = actionHelper.reportData(commandedBy, actionId, &packet);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
     case (RESET_REBOOT_COUNTERS): {
       if (size == 0) {
         resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
@@ -300,6 +396,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 +461,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 +513,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 +549,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 +576,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 +610,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 +627,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 +714,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 +751,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 +778,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 +798,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 +1004,152 @@ 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;
+    }
+  }
+  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;
+  dumpContext.totalFileSize = std::filesystem::file_size(LIST_DIR_DUMP_WORK_FILE, e);
+  dumpContext.segmentIdx = 0;
+  dumpContext.dumpedBytes = 0;
+  size_t nextDumpLen = 0;
+  size_t dummy = 0;
+  dumpContext.maxDumpLen = dirListingBuf.size() - 2 * sizeof(uint32_t) - 1 - repoNameLen - 1;
+  dumpContext.listingDataOffset = 2 * sizeof(uint32_t) + 1 + repoNameLen + 1;
+  uint32_t chunks = dumpContext.totalFileSize / dumpContext.maxDumpLen;
+  if (dumpContext.totalFileSize % dumpContext.maxDumpLen != 0) {
+    chunks++;
+  }
+  SerializeAdapter::serialize(&chunks, dirListingBuf.data() + sizeof(uint32_t), &dummy,
+                              dirListingBuf.size() - sizeof(uint32_t),
+                              SerializeIF::Endianness::NETWORK);
+  while (dumpContext.dumpedBytes < dumpContext.totalFileSize) {
+    ifile.seekg(dumpContext.dumpedBytes, std::ios::beg);
+    nextDumpLen = dumpContext.maxDumpLen;
+    if (dumpContext.totalFileSize - dumpContext.dumpedBytes < dumpContext.maxDumpLen) {
+      nextDumpLen = dumpContext.totalFileSize - dumpContext.dumpedBytes;
+    }
+    SerializeAdapter::serialize(&dumpContext.segmentIdx, dirListingBuf.data(), &dummy,
+                                dirListingBuf.size(), SerializeIF::Endianness::NETWORK);
+    ifile.read(reinterpret_cast<char *>(dirListingBuf.data() + dumpContext.listingDataOffset),
+               nextDumpLen);
+    result = actionHelper.reportData(commandedBy, actionId, dirListingBuf.data(),
+                                     dumpContext.listingDataOffset + nextDumpLen);
+    if (result != returnvalue::OK) {
+      // Remove work file when we are done
+      std::filesystem::remove(LIST_DIR_DUMP_WORK_FILE, e);
+      return result;
+    }
+    dumpContext.segmentIdx++;
+    dumpContext.dumpedBytes += nextDumpLen;
+    // Dump takes multiple task cycles, so cache the dump state and continue dump the next cycles.
+    if (dumpContext.segmentIdx == 10) {
+      dumpContext.active = true;
+      dumpContext.firstDump = true;
+      dumpContext.commander = commandedBy;
+      dumpContext.actionId = actionId;
+      return returnvalue::OK;
+    }
+  }
+  // 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 +1277,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 +1537,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 +1619,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 +1673,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;
   }
@@ -1715,7 +2010,6 @@ bool CoreController::parseRebootFile(std::string path, RebootFile &rf) {
 
 void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
   std::string path = currMntPrefix + REBOOT_FILE;
-  // Disable the reboot file mechanism
   parseRebootFile(path, rebootFile);
   if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
     rebootFile.img00Cnt = 0;
@@ -1928,11 +2222,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 +2318,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 +2342,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 +2359,118 @@ 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();
+}
+
+void CoreController::dirListingDumpHandler() {
+  if (dumpContext.firstDump) {
+    dumpContext.firstDump = false;
+    return;
+  }
+  size_t nextDumpLen = 0;
+  size_t dummy = 0;
+  ReturnValue_t result;
+  std::error_code e;
+  std::ifstream ifile(LIST_DIR_DUMP_WORK_FILE, std::ios::binary);
+  if (ifile.bad()) {
+    return;
+  }
+  while (dumpContext.dumpedBytes < dumpContext.totalFileSize) {
+    ifile.seekg(dumpContext.dumpedBytes, std::ios::beg);
+    nextDumpLen = dumpContext.maxDumpLen;
+    if (dumpContext.totalFileSize - dumpContext.dumpedBytes < dumpContext.maxDumpLen) {
+      nextDumpLen = dumpContext.totalFileSize - dumpContext.dumpedBytes;
+    }
+    SerializeAdapter::serialize(&dumpContext.segmentIdx, dirListingBuf.data(), &dummy,
+                                dirListingBuf.size(), SerializeIF::Endianness::NETWORK);
+    ifile.read(reinterpret_cast<char *>(dirListingBuf.data() + dumpContext.listingDataOffset),
+               nextDumpLen);
+    result =
+        actionHelper.reportData(dumpContext.commander, dumpContext.actionId, dirListingBuf.data(),
+                                dumpContext.listingDataOffset + nextDumpLen);
+    if (result != returnvalue::OK) {
+      // Remove work file when we are done
+      std::filesystem::remove(LIST_DIR_DUMP_WORK_FILE, e);
+      dumpContext.active = false;
+      actionHelper.finish(false, dumpContext.commander, dumpContext.actionId, result);
+      return;
+    }
+    dumpContext.segmentIdx++;
+    dumpContext.dumpedBytes += nextDumpLen;
+    // Dump takes multiple task cycles, so cache the dump state and continue dump the next cycles.
+    if (dumpContext.segmentIdx == 10) {
+      break;
+    }
+  }
+  if (dumpContext.dumpedBytes >= dumpContext.totalFileSize) {
+    actionHelper.finish(true, dumpContext.commander, dumpContext.actionId, result);
+    dumpContext.active = false;
+    // Remove work file when we are done
+    std::filesystem::remove(LIST_DIR_DUMP_WORK_FILE, e);
+  }
+}
+
+void CoreController::announceVersionInfo() {
+  using namespace core;
+  uint32_t p1 = (common::OBSW_VERSION_MAJOR << 24) | (common::OBSW_VERSION_MINOR << 16) |
+                (common::OBSW_VERSION_REVISION << 8);
+  uint32_t p2 = 0;
+  if (strcmp("", common::OBSW_VERSION_CST_GIT_SHA1) != 0) {
+    p1 |= 1;
+    auto shaAsStr = std::string(common::OBSW_VERSION_CST_GIT_SHA1);
+    size_t posDash = shaAsStr.find("-");
+    auto gitHash = shaAsStr.substr(posDash + 2, 4);
+    // Only copy first 4 letters of git hash
+    memcpy(&p2, gitHash.c_str(), 4);
+  }
+
+  triggerEvent(VERSION_INFO, p1, p2);
+  if (mappedSysRomAddr != nullptr) {
+    uint32_t p1Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr));
+    uint32_t p2Firmware = *(reinterpret_cast<uint32_t *>(mappedSysRomAddr) + 1);
+    triggerEvent(FIRMWARE_INFO, p1Firmware, p2Firmware);
+  }
+}
+
+void CoreController::announceCurrentImageInfo() {
+  using namespace core;
+  triggerEvent(CURRENT_IMAGE_INFO, CURRENT_CHIP, CURRENT_COPY);
 }
 
 bool CoreController::isNumber(const std::string &s) {
   return !s.empty() && std::find_if(s.begin(), s.end(),
                                     [](unsigned char c) { return !std::isdigit(c); }) == s.end();
 }
+
+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,9 @@
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
+#include <fsfw/parameters/ParameterHelper.h>
+#include <fsfw/parameters/ReceivesParameterMessagesIF.h>
+#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
 #include <mission/acs/archive/GPSDefinitions.h>
 #include <mission/utility/trace.h>
@@ -16,17 +19,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 +45,65 @@ struct RebootFile {
   xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
-class CoreController : public ExtendedControllerBase {
+class RebootMechanismPacket : public SerialLinkedListAdapter<SerializeIF> {
  public:
+  RebootMechanismPacket(RebootFile& rf) {
+    enabled = rf.enabled;
+    maxCount = rf.maxCount;
+    img00Count = rf.img00Cnt;
+    img01Count = rf.img01Cnt;
+    img10Count = rf.img10Cnt;
+    img11Count = rf.img11Cnt;
+    img00Lock = rf.img00Lock;
+    img01Lock = rf.img01Lock;
+    img10Lock = rf.img10Lock;
+    img11Lock = rf.img11Lock;
+    lastChip = static_cast<uint8_t>(rf.lastChip);
+    lastCopy = static_cast<uint8_t>(rf.lastCopy);
+    nextChip = static_cast<uint8_t>(rf.mechanismNextChip);
+    nextCopy = static_cast<uint8_t>(rf.mechanismNextCopy);
+    setLinks();
+  }
+
+ private:
+  void setLinks() {
+    setStart(&enabled);
+    enabled.setNext(&maxCount);
+    maxCount.setNext(&img00Count);
+    img00Count.setNext(&img01Count);
+    img01Count.setNext(&img10Count);
+    img10Count.setNext(&img11Count);
+    img11Count.setNext(&img00Lock);
+    img00Lock.setNext(&img01Lock);
+    img01Lock.setNext(&img10Lock);
+    img10Lock.setNext(&img11Lock);
+    img11Lock.setNext(&lastChip);
+    lastChip.setNext(&lastCopy);
+    lastCopy.setNext(&nextChip);
+    nextChip.setNext(&nextCopy);
+    setLast(&nextCopy);
+  }
+
+  SerializeElement<uint8_t> enabled = false;
+  SerializeElement<uint32_t> maxCount = 0;
+  SerializeElement<uint32_t> img00Count = 0;
+  SerializeElement<uint32_t> img01Count = 0;
+  SerializeElement<uint32_t> img10Count = 0;
+  SerializeElement<uint32_t> img11Count = 0;
+  SerializeElement<uint8_t> img00Lock = false;
+  SerializeElement<uint8_t> img01Lock = false;
+  SerializeElement<uint8_t> img10Lock = false;
+  SerializeElement<uint8_t> img11Lock = false;
+  SerializeElement<uint8_t> lastChip = 0;
+  SerializeElement<uint8_t> lastCopy = 0;
+  SerializeElement<uint8_t> nextChip = 0;
+  SerializeElement<uint8_t> nextCopy = 0;
+};
+
+class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
+ public:
+  enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
+
   static xsc::Chip CURRENT_CHIP;
   static xsc::Copy CURRENT_COPY;
 
@@ -57,85 +111,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 +178,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 +189,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
   };
@@ -206,26 +198,34 @@ class CoreController : public ExtendedControllerBase {
 
   static constexpr bool BLOCKING_SD_INIT = false;
 
+  uint32_t* mappedSysRomAddr = nullptr;
   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 {
@@ -234,6 +234,20 @@ class CoreController : public ExtendedControllerBase {
     DeviceCommandId_t actionId;
   } sdCommandingInfo;
 
+  struct DirListingDumpContext {
+    bool active;
+    bool firstDump;
+    size_t dumpedBytes;
+    size_t totalFileSize;
+    size_t listingDataOffset;
+    size_t maxDumpLen;
+    uint32_t segmentIdx;
+    MessageQueueId_t commander = MessageQueueIF::NO_QUEUE;
+    DeviceCommandId_t actionId;
+  };
+  std::array<uint8_t, 1024> dirListingBuf{};
+  DirListingDumpContext dumpContext{};
+
   RebootFile rebootFile = {};
 
   CommandExecutor cmdExecutor;
@@ -266,12 +280,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 +309,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 +322,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);
 
@@ -319,7 +344,10 @@ class CoreController : public ExtendedControllerBase {
   bool parseRebootFile(std::string path, RebootFile& file);
   void rewriteRebootFile(RebootFile file);
   void announceBootCounts();
+  void announceVersionInfo();
+  void announceCurrentImageInfo();
   void readHkData();
+  void dirListingDumpHandler();
   bool isNumber(const std::string& s);
 };
 

bsp_q7s/core/ObjectFactory.cpp

@@ -2,6 +2,7 @@
 
 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
+#include <fsfw/tasks/TaskFactory.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@@ -10,10 +11,10 @@
 #include <linux/com/SyrlinksComHandler.h>
 #include <linux/payload/PlocMemoryDumper.h>
 #include <linux/payload/PlocMpsocHandler.h>
-#include <linux/payload/PlocMpsocHelper.h>
+#include <linux/payload/PlocMpsocSpecialComHelper.h>
 #include <linux/payload/PlocSupervisorHandler.h>
 #include <linux/payload/ScexUartReader.h>
-#include <linux/payload/plocMpscoDefs.h>
+#include <linux/payload/plocMpsocHelpers.h>
 #include <linux/power/CspComIF.h>
 #include <mission/acs/GyrL3gCustomHandler.h>
 #include <mission/acs/MgmLis3CustomHandler.h>
@@ -27,8 +28,9 @@
 #include <mission/system/acs/ImtqAssembly.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/SyrlinksAssembly.h>
+#include <mission/system/tcs/TmpDevFdir.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
@@ -62,17 +64,15 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.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
@@ -123,6 +123,9 @@ 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;
@@ -164,6 +167,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,
@@ -186,7 +190,6 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
   *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
   *uartComIF = new SerialComIF(objects::UART_COM_IF);
   *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, **gpioComIF);
-  //*spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher,
@@ -194,7 +197,6 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_SIZE, addresses::P60DOCK, 500);
   CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU1, 500);
   CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU2, 500);
-  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
 
   auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER);
   P60DockHandler* p60dockhandler = new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF,
@@ -208,9 +210,12 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   Pdu2Handler* pdu2handler = new Pdu2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF,
                                              pdu2CspCookie, pdu2Fdir, enableHkSets);
 
+#if OBSW_ADD_GOMSPACE_ACU == 1
+  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
   auto acuFdir = new GomspacePowerFdir(objects::ACU_HANDLER);
   ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie,
                                           acuFdir, enableHkSets);
+#endif
   auto pcduHandler = new PcduHandler(objects::PCDU_HANDLER, 50);
 
   /**
@@ -220,7 +225,9 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   p60dockhandler->setModeNormal();
   pdu1handler->setModeNormal();
   pdu2handler->setModeNormal();
+#if OBSW_ADD_GOMSPACE_ACU == 1
   acuhandler->setModeNormal();
+#endif
   if (pwrSwitcher != nullptr) {
     *pwrSwitcher = pcduHandler;
   }
@@ -234,20 +241,7 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
 
 ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
                                                       Stack5VHandler& stackHandler) {
-  using namespace gpio;
-  if (gpioComIF == nullptr) {
-    return returnvalue::FAILED;
-  }
-  GpioCookie* gpioCookieRadSensor = new GpioCookie;
-  std::stringstream consumer;
-  consumer << "0x" << std::hex << objects::RAD_SENSOR;
-  GpiodRegularByLineName* gpio = new GpiodRegularByLineName(
-      q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH);
-  gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), Direction::OUT,
-                                    Levels::LOW);
-  gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
-  gpioChecker(gpioComIF->addGpios(gpioCookieRadSensor), "RAD sensor");
+  createRadSensorChipSelect(gpioComIF);
 
   SpiCookie* spiCookieRadSensor =
       new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
@@ -360,7 +354,8 @@ void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {
 }
 
 void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
-                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
+                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher,
+                                             bool enableHkSets, adis1650x::Type adisType) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
   createAcsBoardGpios(*gpioCookieAcsBoard);
@@ -446,9 +441,8 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
       new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, adis1650x::MAXIMUM_REPLY_SIZE,
                     spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  auto adisHandler =
-      new GyrAdis1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::ACS_BOARD_POLLING_TASK,
-                              spiCookie, adis1650x::Type::ADIS16505);
+  auto adisHandler = new GyrAdis1650XHandler(objects::GYRO_0_ADIS_HANDLER,
+                                             objects::ACS_BOARD_POLLING_TASK, spiCookie, adisType);
   fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
   assemblyChildren[4] = adisHandler;
@@ -481,9 +475,8 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
       new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, adis1650x::MAXIMUM_REPLY_SIZE,
                     spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::ACS_BOARD_CS_TIMEOUT);
-  adisHandler =
-      new GyrAdis1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::ACS_BOARD_POLLING_TASK,
-                              spiCookie, adis1650x::Type::ADIS16505);
+  adisHandler = new GyrAdis1650XHandler(objects::GYRO_2_ADIS_HANDLER,
+                                        objects::ACS_BOARD_POLLING_TASK, spiCookie, adisType);
   fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
   assemblyChildren[6] = adisHandler;
@@ -513,9 +506,9 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
   debugGps = true;
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 100;
-  auto gpsCtrl =
-      new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
+  RESET_ARGS_GNSS.waitPeriodMs = 5;
+  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);
@@ -631,8 +624,8 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
       new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
                        serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
   mpsocCookie->setNoFixedSizeReply();
-  auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-  auto* mpsocHandler = new PlocMPSoCHandler(
+  auto plocMpsocHelper = new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER);
+  auto* mpsocHandler = new PlocMpsocHandler(
       objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, plocMpsocHelper,
       Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), objects::PLOC_SUPERVISOR_HANDLER);
   mpsocHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
@@ -652,6 +645,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
                                                 Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
                                                 power::PDU1_CH6_PLOC_12V, *supvHelper);
+  supvHandler->setPowerSwitcher(&pwrSwitch);
   supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
   static_cast<void>(consumer);
@@ -737,20 +731,12 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
   GpiodRegularByLineName* gpio = nullptr;
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, "PAPB VC0");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, "PAPB VC0");
   gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, "PAPB VC1");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC1, "PAPB VC1");
   gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, "PAPB VC2");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, "PAPB VC2");
   gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio);
-  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, "PAPB VC3");
-  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
@@ -759,18 +745,14 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
   // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-  VirtualChannelIF* vc1 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-  VirtualChannelIF* vc2 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc3 =
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY,
-                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
+  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
+  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
+  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
+  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
   // Creating ptme object and adding virtual channel interfaces
   Ptme* ptme = new Ptme(objects::PTME);
   ptme->addVcInterface(ccsds::VC0, vc0);
@@ -812,7 +794,7 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   // Core task which handles the HK store and takes care of dumping it as TM using a VC directly
   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(),
+      persTmStore::DUMP_HK_STORE_DONE, persTmStore::DUMP_HK_CANCELLED, *SdCardManager::instance(),
       PTME_LOCKED);
   hkStore->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
@@ -1015,3 +997,36 @@ void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) {
     sif::warning << "Sending mode command failed" << std::endl;
   }
 }
+
+void ObjectFactory::createRadSensorChipSelect(LinuxLibgpioIF* gpioIF) {
+  using namespace gpio;
+  if (gpioIF == nullptr) {
+    return;
+  }
+  GpioCookie* gpioCookieRadSensor = new GpioCookie;
+  std::stringstream consumer;
+  consumer << "0x" << std::hex << objects::RAD_SENSOR;
+  GpiodRegularByLineName* gpio = new GpiodRegularByLineName(
+      q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), Direction::OUT, Levels::HIGH);
+  gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio);
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), Direction::OUT,
+                                    Levels::LOW);
+  gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
+  gpioChecker(gpioIF->addGpios(gpioCookieRadSensor), "RAD sensor");
+}
+
+void ObjectFactory::createPlI2cResetGpio(LinuxLibgpioIF* gpioIF) {
+  using namespace gpio;
+  if (gpioIF == nullptr) {
+    return;
+  }
+  GpioCookie* gpioI2cResetnCookie = new GpioCookie;
+  GpiodRegularByLineName* gpioI2cResetn = new GpiodRegularByLineName(
+      q7s::gpioNames::PL_I2C_ARESETN, "PL_I2C_ARESETN", Direction::OUT, Levels::HIGH);
+  gpioI2cResetnCookie->addGpio(gpioIds::PL_I2C_ARESETN, gpioI2cResetn);
+  gpioChecker(gpioIF->addGpios(gpioI2cResetnCookie), "PL I2C ARESETN");
+  // Reset I2C explicitely again.
+  gpioIF->pullLow(gpioIds::PL_I2C_ARESETN);
+  TaskFactory::delayTask(1);
+  gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
+}

bsp_q7s/core/ObjectFactory.h

@@ -3,6 +3,7 @@
 
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <mission/acs/gyroAdisHelpers.h>
 #include <mission/com/CcsdsIpCoreHandler.h>
 #include <mission/com/PersistentLogTmStoreTask.h>
 #include <mission/genericFactory.h>
@@ -23,7 +24,6 @@ class HealthTableIF;
 class AcsBoardAssembly;
 class GpioIF;
 
-extern std::atomic_uint16_t I2C_FATAL_ERRORS;
 extern std::atomic_bool PTME_LOCKED;
 
 namespace ObjectFactory {
@@ -59,10 +59,12 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
 void createTmpComponents();
+void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 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,
+                              adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
@@ -76,6 +78,7 @@ ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);
+void createPlI2cResetGpio(LinuxLibgpioIF* gpioComIF);
 
 void testAcsBrdAss(AcsBoardAssembly* assAss);
 

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) {
@@ -302,6 +302,9 @@ void scheduling::initTasks() {
 
   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) {
@@ -317,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(
@@ -344,7 +345,6 @@ void scheduling::initTasks() {
   }
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-  // TODO: Use regular scheduler for this task
 #if OBSW_ADD_PLOC_MPSOC == 1
   PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
       "PLOC_MPSOC_HELPER", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
@@ -365,7 +365,7 @@ void scheduling::initTasks() {
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */
 
   PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc, &RR_SCHEDULING);
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);
   plTask->addComponent(objects::CAM_SWITCHER);
   scheduling::addMpsocSupvHandlers(plTask);
   scheduling::scheduleScexDev(plTask);
@@ -471,6 +471,9 @@ void scheduling::initTasks() {
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+#if OBSW_ADD_PLOC_MPSOC == 1
+  mpsocHelperTask->startTask();
+#endif
   plTask->startTask();
 
 #if OBSW_ADD_TEST_CODE == 1

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"
@@ -36,7 +36,8 @@ void ObjectFactory::produce(void* args) {
 
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -46,16 +47,26 @@ void ObjectFactory::produce(void* args) {
   /* Adding gpios for chip select decoding to the gpioComIf */
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPlI2cResetGpio(gpioComIF);
 
   // Hardware is usually not connected to EM, so we need to create dummies which replace lower
   // level components.
   dummy::DummyCfg dummyCfg;
   dummyCfg.addCoreCtrlCfg = false;
+  dummyCfg.addCamSwitcherDummy = false;
 #if OBSW_ADD_SYRLINKS == 1
   dummyCfg.addSyrlinksDummies = false;
 #endif
+#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
+  dummyCfg.addPlocDummies = false;
+#endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
+  // The ACU broke.
+  dummyCfg.addOnlyAcuDummy = true;
+#endif
+#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
+  dummyCfg.addBpxBattDummy = false;
 #endif
 #if OBSW_ADD_ACS_BOARD == 1
   dummyCfg.addAcsBoardDummies = false;
@@ -63,33 +74,21 @@ 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);
+  dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF, enableHkSets);
 
-  new CoreController(objects::CORE_CONTROLLER, I2C_FATAL_ERRORS, enableHkSets);
-
-  // Regular FM code, does not work for EM if the hardware is not connected
-  // createPcduComponents(gpioComIF, &pwrSwitcher);
-  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
-  // createSyrlinksComponents(pwrSwitcher);
-  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
-  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  // createTmpComponents();
-  // createSolarArrayDeploymentComponents();
-  // createPayloadComponents(gpioComIF);
-  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-
-  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
-  //       and will cause xsc_boot_copy commands to always boot to 0 0
-  // createRadSensorComponent(gpioComIF);
+  new CoreController(objects::CORE_CONTROLLER, enableHkSets);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  // Still initialize chip select to avoid SPI bus issues.
+  createRadSensorChipSelect(gpioComIF);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
+                           adis1650x::Type::ADIS16507);
 #else
   // Still add all GPIOs for EM.
   GpioCookie* acsBoardGpios = new GpioCookie();
@@ -117,6 +116,8 @@ void ObjectFactory::produce(void* args) {
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
+  createPayloadComponents(gpioComIF, *pwrSwitcher);
+
 #if OBSW_ADD_CCSDS_IP_CORES == 1
   CcsdsIpCoreHandler* ipCoreHandler = nullptr;
   CcsdsComponentArgs ccsdsArgs(*gpioComIF, *ipcStore, *tmStore, stores, *pusFunnel, *cfdpFunnel,
@@ -125,6 +126,7 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_TM_TO_PTME == 1
   if (ccsdsArgs.liveDestination != nullptr) {
     pusFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
+    cfdpFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
   }
 #endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
@@ -134,7 +136,7 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
 #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
   createAcsController(true, enableHkSets);
   HeaterHandler* heaterHandler;

bsp_q7s/fmObjectFactory.cpp

@@ -1,7 +1,9 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <devices/gpioIds.h>
 #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 +15,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) {
@@ -31,7 +33,8 @@ void ObjectFactory::produce(void* args) {
 
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -42,9 +45,12 @@ void ObjectFactory::produce(void* args) {
   /* Adding gpios for chip select decoding to the gpioComIf */
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPlI2cResetGpio(gpioComIF);
 
-  new CoreController(objects::CORE_CONTROLLER, 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 +61,8 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
+                           adis1650x::Type::ADIS16505);
 #endif
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
@@ -91,6 +98,7 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_TM_TO_PTME == 1
   if (ccsdsArgs.liveDestination != nullptr) {
     pusFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
+    cfdpFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
   }
 #endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 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"
 

cmake/Zynq7020CrossCompileConfig.cmake

@@ -40,8 +40,8 @@ set(CROSS_COMPILE_OBJCOPY "${CROSS_COMPILE}-objcopy")
 set(CROSS_COMPILE_SIZE "${CROSS_COMPILE}-size")
 
 # At the very least, cross compile gcc and g++ have to be set!
-find_program (CMAKE_C_COMPILER ${CROSS_COMPILE_CC} REQUIRED)
-find_program (CMAKE_CXX_COMPILER ${CROSS_COMPILE_CXX} REQUIRED)
+find_program (CMAKE_C_COMPILER ${CROSS_COMPILE_CC} HINTS $ENV{CROSS_COMPILE_BIN_PATH} REQUIRED)
+find_program (CMAKE_CXX_COMPILER ${CROSS_COMPILE_CXX} HINTS $ENV{CROSS_COMPILE_BIN_PATH} REQUIRED)
 # Useful utilities, not strictly necessary
 find_program(CMAKE_SIZE ${CROSS_COMPILE_SIZE})
 find_program(CMAKE_OBJCOPY ${CROSS_COMPILE_OBJCOPY})

common/config/devices/gpioIds.h

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

common/config/devices/heaterSwitcherList.h

@@ -1,20 +0,0 @@
-#ifndef FSFWCONFIG_DEVICES_HEATERSWITCHERLIST_H_
-#define FSFWCONFIG_DEVICES_HEATERSWITCHERLIST_H_
-
-#include <cstdint>
-
-namespace heater {
-enum Switchers : uint8_t {
-  HEATER_0_OBC_BRD,
-  HEATER_1_PLOC_PROC_BRD,
-  HEATER_2_ACS_BRD,
-  HEATER_3_PCDU_PDU,
-  HEATER_4_CAMERA,
-  HEATER_5_STR,
-  HEATER_6_DRO,
-  HEATER_7_S_BAND,
-  NUMBER_OF_SWITCHES
-};
-}
-
-#endif /* FSFWCONFIG_DEVICES_HEATERSWITCHERLIST_H_ */

common/config/eive/definitions.h

@@ -34,8 +34,8 @@ static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50;
 static constexpr uint8_t LIVE_TM = 0;
 
 /* Limits for filename and path checks */
-static constexpr uint32_t MAX_PATH_SIZE = 100;
-static constexpr uint32_t MAX_FILENAME_SIZE = 50;
+static constexpr uint32_t MAX_PATH_SIZE = 200;
+static constexpr uint32_t MAX_FILENAME_SIZE = 100;
 
 static constexpr uint32_t SA_DEPL_INIT_BUFFER_SECS = 120;
 // Burn time for autonomous deployment
@@ -58,7 +58,9 @@ static constexpr uint32_t CFDP_STORE_QUEUE_SIZE = 300;
 
 static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
 static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 80;
+static constexpr uint32_t VERIFICATION_SERVICE_QUEUE_DEPTH = 120;
 static constexpr uint32_t HK_SERVICE_QUEUE_DEPTH = 60;
+static constexpr uint32_t ACTION_SERVICE_QUEUE_DEPTH = 60;
 
 static constexpr uint32_t MAX_STORED_CMDS_UDP = 150;
 static constexpr uint32_t MAX_STORED_CMDS_TCP = 180;

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

@@ -2,8 +2,11 @@
 
 #include <mission/power/gsDefs.h>
 
-AcuDummy::AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+AcuDummy::AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie, bool enableHkSets)
+    : DeviceHandlerBase(objectId, comif, comCookie),
+      coreHk(this),
+      auxHk(this),
+      enableHkSets(enableHkSets) {}
 
 AcuDummy::~AcuDummy() {}
 
@@ -37,7 +40,49 @@ uint32_t AcuDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t AcuDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
+  using namespace ACU;
+  localDataPoolMap.emplace(pool::ACU_CURRENT_IN_CHANNELS, new PoolEntry<int16_t>(6));
+  localDataPoolMap.emplace(pool::ACU_VOLTAGE_IN_CHANNELS, new PoolEntry<uint16_t>(6));
+
+  localDataPoolMap.emplace(pool::ACU_VCC, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_VBAT, new PoolEntry<uint16_t>({0}));
+
   localDataPoolMap.emplace(ACU::pool::ACU_TEMPERATURES,
                            new PoolEntry<float>({10.0, 10.0, 10.0}, true));
+
+  localDataPoolMap.emplace(pool::ACU_MPPT_MODE, new PoolEntry<uint8_t>({0}));
+
+  localDataPoolMap.emplace(pool::ACU_VBOOST_IN_CHANNELS, new PoolEntry<uint16_t>(6));
+  localDataPoolMap.emplace(pool::ACU_POWER_IN_CHANNELS, new PoolEntry<uint16_t>(6));
+
+  localDataPoolMap.emplace(pool::ACU_DAC_ENABLES, new PoolEntry<uint8_t>(3));
+  localDataPoolMap.emplace(pool::ACU_DAC_RAW_CHANNELS, new PoolEntry<uint16_t>(6));
+
+  localDataPoolMap.emplace(pool::ACU_BOOTCAUSE, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_BOOTCNT, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_UPTIME, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_RESET_CAUSE, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_MPPT_TIME, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_MPPT_PERIOD, new PoolEntry<uint16_t>({0}));
+
+  localDataPoolMap.emplace(pool::ACU_DEVICES, new PoolEntry<uint8_t>(8));
+  localDataPoolMap.emplace(pool::ACU_DEVICES_STATUS, new PoolEntry<uint8_t>(8));
+
+  localDataPoolMap.emplace(pool::ACU_WDT_CNT_GND, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(pool::ACU_WDT_GND_LEFT, new PoolEntry<uint32_t>({0}));
+
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(coreHk.getSid(), enableHkSets, 30.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(auxHk.getSid(), enableHkSets, 6000.0));
   return returnvalue::OK;
 }
+
+LocalPoolDataSetBase *AcuDummy::getDataSetHandle(sid_t sid) {
+  if (sid == coreHk.getSid()) {
+    return &coreHk;
+  } else if (sid == auxHk.getSid()) {
+    return &auxHk;
+  }
+  return nullptr;
+}

dummies/AcuDummy.h

@@ -2,6 +2,7 @@
 #define DUMMIES_ACUDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/power/gsDefs.h>
 
 class AcuDummy : public DeviceHandlerBase {
  public:
@@ -11,10 +12,14 @@ class AcuDummy : public DeviceHandlerBase {
   static const uint8_t SIMPLE_COMMAND_DATA = 1;
   static const uint8_t PERIODIC_REPLY_DATA = 2;
 
-  AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie, bool enableHkSets);
   virtual ~AcuDummy();
 
  protected:
+  ACU::CoreHk coreHk;
+  ACU::AuxHk auxHk;
+  bool enableHkSets;
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
@@ -28,6 +33,7 @@ class AcuDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 };
 
 #endif /* DUMMIES_ACUDUMMY_H_ */

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

@@ -2,15 +2,34 @@
 
 #include <mission/acs/imtqHelpers.h>
 
-ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie) {}
+ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
+                     power::Switch_t pwrSwitcher, bool enableHkSets)
+    : DeviceHandlerBase(objectId, comif, comCookie),
+      enableHkSets(enableHkSets),
+      statusSet(this),
+      dipoleSet(*this),
+      rawMtmNoTorque(this),
+      hkDatasetNoTorque(this),
+      rawMtmWithTorque(this),
+      hkDatasetWithTorque(this),
+      calMtmMeasurementSet(this),
+      switcher(pwrSwitcher) {}
 
 ImtqDummy::~ImtqDummy() = default;
 
-void ImtqDummy::doStartUp() { setMode(MODE_NORMAL); }
+void ImtqDummy::doStartUp() { setMode(MODE_ON); }
 
 void ImtqDummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
 
+ReturnValue_t ImtqDummy::getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) {
+  if (switcher != power::NO_SWITCH) {
+    *numberOfSwitches = 1;
+    *switches = &switcher;
+    return returnvalue::OK;
+  }
+  return DeviceHandlerBase::NO_SWITCH;
+}
+
 ReturnValue_t ImtqDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
 ReturnValue_t ImtqDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
@@ -43,5 +62,59 @@ 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}));
+
+  // ENG HK No Torque
+  localDataPoolMap.emplace(imtq::DIGITAL_VOLTAGE_MV, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(imtq::ANALOG_VOLTAGE_MV, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(imtq::DIGITAL_CURRENT, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(imtq::ANALOG_CURRENT, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(imtq::COIL_CURRENTS, &coilCurrentsMilliampsNoTorque);
+  localDataPoolMap.emplace(imtq::COIL_TEMPERATURES, &coilTempsNoTorque);
+  localDataPoolMap.emplace(imtq::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
+
+  // ENG HK With Torque
+  localDataPoolMap.emplace(imtq::DIGITAL_VOLTAGE_MV_WT, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(imtq::ANALOG_VOLTAGE_MV_WT, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(imtq::DIGITAL_CURRENT_WT, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(imtq::ANALOG_CURRENT_WT, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(imtq::COIL_CURRENTS_WT, &coilCurrentsMilliampsWithTorque);
+  localDataPoolMap.emplace(imtq::COIL_TEMPERATURES_WT, &coilTempsWithTorque);
+  localDataPoolMap.emplace(imtq::MCU_TEMPERATURE_WT, new PoolEntry<int16_t>({0}));
+
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(rawMtmWithTorque.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(calMtmMeasurementSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(statusSet.getSid(), false, 10.0));
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(dipoleSet.getSid(), false, 10.0));
   return DeviceHandlerBase::initializeLocalDataPool(localDataPoolMap, poolManager);
 }
+
+LocalPoolDataSetBase *ImtqDummy::getDataSetHandle(sid_t sid) {
+  if (sid == hkDatasetNoTorque.getSid()) {
+    return &hkDatasetNoTorque;
+  } else if (sid == dipoleSet.getSid()) {
+    return &dipoleSet;
+  } else if (sid == statusSet.getSid()) {
+    return &statusSet;
+  } else if (sid == hkDatasetWithTorque.getSid()) {
+    return &hkDatasetWithTorque;
+  } else if (sid == rawMtmWithTorque.getSid()) {
+    return &rawMtmWithTorque;
+  } else if (sid == calMtmMeasurementSet.getSid()) {
+    return &calMtmMeasurementSet;
+  } else if (sid == rawMtmNoTorque.getSid()) {
+    return &rawMtmNoTorque;
+  }
+  return nullptr;
+}

dummies/ImtqDummy.h

@@ -3,6 +3,8 @@
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
+#include "mission/acs/imtqHelpers.h"
+
 class ImtqDummy : public DeviceHandlerBase {
  public:
   static const DeviceCommandId_t SIMPLE_COMMAND = 1;
@@ -11,10 +13,44 @@ class ImtqDummy : public DeviceHandlerBase {
   static const uint8_t SIMPLE_COMMAND_DATA = 1;
   static const uint8_t PERIODIC_REPLY_DATA = 2;
 
-  ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
+            power::Switch_t pwrSwitcher, bool enableHkSets);
   ~ImtqDummy() override;
 
  protected:
+  bool enableHkSets;
+
+  imtq::StatusDataset statusSet;
+  imtq::DipoleActuationSet dipoleSet;
+  imtq::RawMtmMeasurementNoTorque rawMtmNoTorque;
+  imtq::HkDatasetNoTorque hkDatasetNoTorque;
+
+  imtq::RawMtmMeasurementWithTorque rawMtmWithTorque;
+  imtq::HkDatasetWithTorque hkDatasetWithTorque;
+
+  imtq::CalibratedMtmMeasurementSet calMtmMeasurementSet;
+
+  PoolEntry<uint8_t> statusMode = PoolEntry<uint8_t>({0});
+  PoolEntry<uint8_t> statusError = PoolEntry<uint8_t>({0});
+  PoolEntry<uint8_t> statusConfig = PoolEntry<uint8_t>({0});
+  PoolEntry<uint32_t> statusUptime = PoolEntry<uint32_t>({0});
+
+  PoolEntry<int32_t> mgmCalEntry = PoolEntry<int32_t>(3);
+  PoolEntry<int16_t> dipolesPoolEntry = PoolEntry<int16_t>({0, 0, 0}, false);
+  PoolEntry<uint16_t> torqueDurationEntry = PoolEntry<uint16_t>({0}, false);
+  PoolEntry<float> coilCurrentsMilliampsNoTorque = PoolEntry<float>(3);
+  PoolEntry<float> coilCurrentsMilliampsWithTorque = PoolEntry<float>(3);
+  PoolEntry<int16_t> coilTempsNoTorque = PoolEntry<int16_t>(3);
+  PoolEntry<int16_t> coilTempsWithTorque = PoolEntry<int16_t>(3);
+  PoolEntry<float> mtmRawNoTorque = PoolEntry<float>(3);
+  PoolEntry<uint8_t> actStatusNoTorque = PoolEntry<uint8_t>(1);
+  PoolEntry<float> mtmRawWithTorque = PoolEntry<float>(3);
+  PoolEntry<uint8_t> actStatusWithTorque = PoolEntry<uint8_t>(1);
+
+  power::Switch_t switcher = power::NO_SWITCH;
+
+  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
+
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
@@ -28,6 +64,7 @@ class ImtqDummy : public DeviceHandlerBase {
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 };
 
 #endif /* DUMMIES_IMTQDUMMY_H_ */

dummies/PcduHandlerDummy.cpp

@@ -1,49 +1,20 @@
 #include "PcduHandlerDummy.h"
 
+#include <fsfw/ipc/QueueFactory.h>
 #include <mission/power/gsDefs.h>
 
 #include "mission/power/defs.h"
 
-PcduHandlerDummy::PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie), dummySwitcher(objectId, 18, 18, false) {
+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;
 }
 
@@ -76,7 +47,8 @@ ReturnValue_t PcduHandlerDummy::getFuseState(uint8_t fuseNr) const {
 
 uint32_t PcduHandlerDummy::getSwitchDelayMs(void) const { return dummySwitcher.getSwitchDelayMs(); }
 
-void PcduHandlerDummy::performOperationHook() {
+ReturnValue_t PcduHandlerDummy::performOperation(uint8_t opCode) {
+  // TODO: Handle HK messages in queue.
   SwitcherBoolArray switcherChangeCopy{};
   {
     MutexGuard mg(switcherLock);
@@ -93,4 +65,18 @@ void PcduHandlerDummy::performOperationHook() {
       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,33 +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:
-  MutexIF *switcherLock;
+  MessageQueueIF* queue;
+  LocalDataPoolManager manager;
+  MutexIF* switcherLock;
   DummyPowerSwitcher dummySwitcher;
   using SwitcherBoolArray = std::array<bool, 18>;
 
+  ReturnValue_t performOperation(uint8_t opCode) override;
   SwitcherBoolArray switchChangeArray{};
-  void performOperationHook() override;
-  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 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/RwDummy.cpp

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

dummies/RwDummy.h

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

@@ -1,5 +1,6 @@
 #include "TemperatureSensorInserter.h"
 
+#include <fsfw/datapool/PoolReadGuard.h>
 #include <objects/systemObjectList.h>
 
 #include <cmath>
@@ -14,10 +15,7 @@ TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
       tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
 
 ReturnValue_t TemperatureSensorInserter::initialize() {
-  if (performTest) {
-    if (testCase == TestCase::COOL_SYRLINKS) {
-    }
-  }
+  testCase = TestCase::NONE;
   return returnvalue::OK;
 }
 
@@ -33,35 +31,82 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
     tempsWereInitialized = true;
   }
 
-  if (cycles == 10) {
-    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(-100, true);
-    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(-100, 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);
+      }
+    }
   }
-
-  if (cycles == 35) {
-    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(0, true);
-    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(0, true);
-    max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-100, true);
-  }
-  if (cycles == 60) {
-    max31865DummyMap[objects::RTD_9_IC12_HPA]->setTemperature(-100, true);
-    max31865DummyMap[objects::RTD_11_IC14_MPA]->setTemperature(0, true);
-  }
-
-  /*
-  ReturnValue_t result = max31865PlocHeatspreaderSet.read();
-  if (result != returnvalue::OK) {
-    sif::warning << "Failed to read temperature from MAX31865 dataset" << std::endl;
-  }
-  max31865PlocHeatspreaderSet.rtdValue = value - 5;
-  max31865PlocHeatspreaderSet.temperatureCelcius = value;
-  if ((iteration % 100) < 20) {
-    max31865PlocHeatspreaderSet.setValidity(false, true);
-  } else {
-    max31865PlocHeatspreaderSet.setValidity(true, true);
-  }
-  max31865PlocHeatspreaderSet.commit();
-  */
   cycles++;
   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"
@@ -22,11 +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;
   uint32_t cycles = 0;
   bool tempsWereInitialized = false;
-  bool performTest = false;
   TestCase testCase = TestCase::NONE;
 
   // void noise();

dummies/helperFactory.cpp

@@ -30,7 +30,7 @@
 #include <mission/system/acs/ImtqAssembly.h>
 #include <mission/system/acs/StrAssembly.h>
 #include <mission/system/objects/CamSwitcher.h>
-#include <mission/system/objects/TcsBoardAssembly.h>
+#include <mission/system/tcs/TcsBoardAssembly.h>
 
 #include "TemperatureSensorInserter.h"
 #include "dummies/Max31865Dummy.h"
@@ -38,13 +38,17 @@
 #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) {
+void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF,
+                          bool enableHkSets) {
   new ComIFDummy(objects::DUMMY_COM_IF);
   auto* comCookieDummy = new ComCookieDummy();
-  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addBpxBattDummy) {
+    new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
   if (cfg.addCoreCtrlCfg) {
     new CoreControllerDummy(objects::CORE_CONTROLLER);
   }
@@ -71,11 +75,15 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   }
   auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
   imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
-  auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy,
+                                  power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
   imtqDummy->enableThermalModule(ThermalStateCfg());
+  imtqDummy->setPowerSwitcher(&pwrSwitcher);
   imtqDummy->connectModeTreeParent(*imtqAssy);
-  if (cfg.addPowerDummies) {
-    new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addOnlyAcuDummy) {
+    new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, enableHkSets);
+  } else if (cfg.addPowerDummies) {
+    new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, enableHkSets);
     new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@@ -193,16 +201,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,9 +221,11 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
       tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
     }
   }
-  auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::Switches::PDU2_CH8_PAYLOAD_CAMERA);
-  camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
+  if (cfg.addCamSwitcherDummy) {
+    auto* camSwitcher = 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);
   auto* plPcduDummy =

dummies/helperFactory.h

@@ -6,17 +6,22 @@ class GpioIF;
 
 namespace dummy {
 
+// Default values targeted towards EM.
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
+  // Special variant because the ACU broke. Overrides addPowerDummies, only ACU dummy will be added.
+  bool addOnlyAcuDummy = false;
   bool addPowerDummies = true;
+  bool addBpxBattDummy = true;
   bool addSyrlinksDummies = true;
   bool addAcsBoardDummies = true;
   bool addSusDummies = true;
   bool addTempSensorDummies = true;
   bool addRtdComIFDummy = true;
   bool addPlocDummies = true;
+  bool addCamSwitcherDummy = false;
 };
 
-void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF);
+void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF, bool enableHkSets);
 
 }  // namespace dummy

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
@@ -173,20 +177,24 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12515;0x30e3;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/acs/StrComHandler.h
 12516;0x30e4;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/acs/StrComHandler.h
 12517;0x30e5;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/acs/StrComHandler.h
-12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/payload/PlocMpsocHelper.h
-12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/payload/PlocMpsocHelper.h
-12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/payload/PlocMpsocHelper.h
-12603;0x313b;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12604;0x313c;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12605;0x313d;MPSOC_MISSING_ACK;LOW;Did not receive acknowledgment report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12606;0x313e;MPSOC_MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12607;0x313f;MPSOC_ACK_FAILURE_REPORT;LOW;Received acknowledgment failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12608;0x3140;MPSOC_EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12609;0x3141;MPSOC_ACK_INVALID_APID;LOW;Expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12610;0x3142;MPSOC_EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12611;0x3143;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHelper.h
-12612;0x3144;MPSOC_TM_SIZE_ERROR;LOW;No description;linux/payload/PlocMpsocHelper.h
-12613;0x3145;MPSOC_TM_CRC_MISSMATCH;LOW;No description;linux/payload/PlocMpsocHelper.h
+12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/payload/PlocMpsocSpecialComHelper.h
+12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;INFO;Flash write successful;linux/payload/PlocMpsocSpecialComHelper.h
+12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12603;0x313b;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12604;0x313c;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12605;0x313d;MPSOC_MISSING_ACK;LOW;Did not receive acknowledgment report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12606;0x313e;MPSOC_MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12607;0x313f;MPSOC_ACK_FAILURE_REPORT;LOW;Received acknowledgment failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12608;0x3140;MPSOC_EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12609;0x3141;MPSOC_ACK_INVALID_APID;LOW;Expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12610;0x3142;MPSOC_EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12611;0x3143;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocSpecialComHelper.h
+12612;0x3144;MPSOC_TM_SIZE_ERROR;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12613;0x3145;MPSOC_TM_CRC_MISSMATCH;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12614;0x3146;MPSOC_FLASH_READ_PACKET_ERROR;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12615;0x3147;MPSOC_FLASH_READ_FAILED;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12616;0x3148;MPSOC_FLASH_READ_SUCCESSFUL;INFO;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12617;0x3149;MPSOC_READ_TIMEOUT;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
 12700;0x319c;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/payload/PayloadPcduHandler.h
 12701;0x319d;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/payload/PayloadPcduHandler.h
 12702;0x319e;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/payload/PayloadPcduHandler.h
@@ -208,7 +216,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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
@@ -251,16 +259,19 @@ 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
+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
+14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@@ -268,6 +279,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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;HIGH;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_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
@@ -497,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
@@ -506,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
@@ -173,20 +177,24 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12515;0x30e3;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/acs/StrComHandler.h
 12516;0x30e4;STR_HELPER_SENDING_PACKET_FAILED;LOW;No description;linux/acs/StrComHandler.h
 12517;0x30e5;STR_HELPER_REQUESTING_MSG_FAILED;LOW;No description;linux/acs/StrComHandler.h
-12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/payload/PlocMpsocHelper.h
-12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/payload/PlocMpsocHelper.h
-12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/payload/PlocMpsocHelper.h
-12603;0x313b;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12604;0x313c;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12605;0x313d;MPSOC_MISSING_ACK;LOW;Did not receive acknowledgment report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12606;0x313e;MPSOC_MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocHelper.h
-12607;0x313f;MPSOC_ACK_FAILURE_REPORT;LOW;Received acknowledgment failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12608;0x3140;MPSOC_EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12609;0x3141;MPSOC_ACK_INVALID_APID;LOW;Expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12610;0x3142;MPSOC_EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocHelper.h
-12611;0x3143;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHelper.h
-12612;0x3144;MPSOC_TM_SIZE_ERROR;LOW;No description;linux/payload/PlocMpsocHelper.h
-12613;0x3145;MPSOC_TM_CRC_MISSMATCH;LOW;No description;linux/payload/PlocMpsocHelper.h
+12600;0x3138;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/payload/PlocMpsocSpecialComHelper.h
+12601;0x3139;MPSOC_FLASH_WRITE_SUCCESSFUL;INFO;Flash write successful;linux/payload/PlocMpsocSpecialComHelper.h
+12602;0x313a;MPSOC_SENDING_COMMAND_FAILED;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12603;0x313b;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12604;0x313c;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12605;0x313d;MPSOC_MISSING_ACK;LOW;Did not receive acknowledgment report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12606;0x313e;MPSOC_MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/payload/PlocMpsocSpecialComHelper.h
+12607;0x313f;MPSOC_ACK_FAILURE_REPORT;LOW;Received acknowledgment failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12608;0x3140;MPSOC_EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12609;0x3141;MPSOC_ACK_INVALID_APID;LOW;Expected acknowledgment report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12610;0x3142;MPSOC_EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/payload/PlocMpsocSpecialComHelper.h
+12611;0x3143;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocSpecialComHelper.h
+12612;0x3144;MPSOC_TM_SIZE_ERROR;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12613;0x3145;MPSOC_TM_CRC_MISSMATCH;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12614;0x3146;MPSOC_FLASH_READ_PACKET_ERROR;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12615;0x3147;MPSOC_FLASH_READ_FAILED;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12616;0x3148;MPSOC_FLASH_READ_SUCCESSFUL;INFO;No description;linux/payload/PlocMpsocSpecialComHelper.h
+12617;0x3149;MPSOC_READ_TIMEOUT;LOW;No description;linux/payload/PlocMpsocSpecialComHelper.h
 12700;0x319c;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/payload/PayloadPcduHandler.h
 12701;0x319d;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/payload/PayloadPcduHandler.h
 12702;0x319e;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/payload/PayloadPcduHandler.h
@@ -208,7 +216,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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
@@ -251,16 +259,19 @@ 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
+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
+14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@@ -268,6 +279,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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;HIGH;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_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
@@ -475,8 +478,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x53b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
 0x53b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
 0x53b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);224;DWLPWRON_CMD;linux/payload/plocMpscoDefs.h
-0x54e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);225;DWLPWRON_CMD;linux/payload/plocMpscoDefs.h
+0x54e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);224;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
+0x54e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);225;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
 0x5700;PLSPVhLP_RequestDone;No description;0;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
 0x5701;PLSPVhLP_NoPacketFound;No description;1;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
 0x5702;PLSPVhLP_DecodeBufTooSmall;No description;2;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
@@ -493,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
@@ -516,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
@@ -542,8 +543,8 @@ 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
+0x65a0;PLMPHLP_FileWriteError;File error occured for file transfers from OBC to the MPSoC.;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
+0x65a1;PLMPHLP_FileReadError;File error occured for file transfers from MPSoC to OBC.;161;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.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
 0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
@@ -583,7 +584,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
@@ -592,21 +593,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 284 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-04 13:59:07
+ * Generated on: 2023-06-21 19:01:02
  */
 #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";
@@ -193,6 +197,10 @@ const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
 const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
 const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
 const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
+const char *MPSOC_FLASH_READ_PACKET_ERROR_STRING = "MPSOC_FLASH_READ_PACKET_ERROR";
+const char *MPSOC_FLASH_READ_FAILED_STRING = "MPSOC_FLASH_READ_FAILED";
+const char *MPSOC_FLASH_READ_SUCCESSFUL_STRING = "MPSOC_FLASH_READ_SUCCESSFUL";
+const char *MPSOC_READ_TIMEOUT_STRING = "MPSOC_READ_TIMEOUT";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@@ -266,7 +274,10 @@ 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 *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -274,6 +285,7 @@ const char *OBC_OVERHEATING_STRING = "OBC_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 +489,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 +617,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):
@@ -668,6 +688,14 @@ const char *translateEvents(Event event) {
       return MPSOC_TM_SIZE_ERROR_STRING;
     case (12613):
       return MPSOC_TM_CRC_MISSMATCH_STRING;
+    case (12614):
+      return MPSOC_FLASH_READ_PACKET_ERROR_STRING;
+    case (12615):
+      return MPSOC_FLASH_READ_FAILED_STRING;
+    case (12616):
+      return MPSOC_FLASH_READ_SUCCESSFUL_STRING;
+    case (12617):
+      return MPSOC_READ_TIMEOUT_STRING;
     case (12700):
       return TRANSITION_BACK_TO_OFF_STRING;
     case (12701):
@@ -815,7 +843,13 @@ 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 (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -830,6 +864,8 @@ const char *translateEvents(Event event) {
       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

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

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,9 @@ 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);
+        adis.decRate = req->cfg.decRateReg;
+        // 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 +123,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 +146,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 +165,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 +185,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 +319,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 +341,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 +368,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];
@@ -365,6 +377,80 @@ void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
   }
 }
 
+ReturnValue_t AcsBoardPolling::writeAdisReg(SpiCookie& cookie) {
+  ReturnValue_t result = returnvalue::OK;
+  int retval = 0;
+  // Prepare transfer
+  int fileDescriptor = 0;
+  std::string device = spiComIF.getSpiDev();
+  UnixFileGuard fileHelper(device, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  if (fileHelper.getOpenResult() != returnvalue::OK) {
+    return spi::OPENING_FILE_FAILED;
+  }
+  spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+  uint32_t spiSpeed = 0;
+  cookie.getSpiParameters(spiMode, spiSpeed, nullptr);
+  spiComIF.setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+  cookie.assignWriteBuffer(cmdBuf.data());
+  cookie.setTransferSize(2);
+
+  gpioId_t gpioId = cookie.getChipSelectPin();
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 0;
+  MutexIF* mutex = spiComIF.getCsMutex();
+  cookie.getMutexParams(timeoutType, timeoutMs);
+  if (mutex == nullptr) {
+    sif::warning << "GyroADIS16507Handler::spiSendCallback: "
+                    "Mutex or GPIO interface invalid"
+                 << std::endl;
+    return returnvalue::FAILED;
+  }
+
+  size_t idx = 0;
+  spi_ioc_transfer* transferStruct = cookie.getTransferStructHandle();
+  uint64_t origTx = transferStruct->tx_buf;
+  uint64_t origRx = transferStruct->rx_buf;
+  for (idx = 0; idx < 4; idx += 2) {
+    result = mutex->lockMutex(timeoutType, timeoutMs);
+    if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "AcsBoardPolling: Failed to lock mutex" << std::endl;
+#endif
+      return result;
+    }
+    // Pull SPI CS low. For now, no support for active high given
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullLow(gpioId);
+    }
+
+    // Execute transfer
+    // Initiate a full duplex SPI transfer.
+    retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), cookie.getTransferStructHandle());
+    if (retval < 0) {
+      utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
+      result = spi::FULL_DUPLEX_TRANSFER_FAILED;
+    }
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+    comIf->performSpiWiretapping(cookie);
+#endif /* FSFW_LINUX_SPI_WIRETAPPING == 1 */
+
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullHigh(gpioId);
+    }
+    mutex->unlockMutex();
+
+    transferStruct->tx_buf += 2;
+    transferStruct->rx_buf += 2;
+    if (idx < 4) {
+      usleep(adis1650x::STALL_TIME_MICROSECONDS);
+    }
+  }
+  transferStruct->tx_buf = origTx;
+  transferStruct->rx_buf = origRx;
+  cookie.setTransferSize(0);
+  return returnvalue::OK;
+}
+
 ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen) {
   ReturnValue_t result = returnvalue::OK;
   int retval = 0;
@@ -373,7 +459,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 +502,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,21 +529,21 @@ 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;
+  uint16_t decRate = 0;
   {
     MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
     mode = gyro.mode;
-    cdHasTimedOut = gyro.countdown.hasTimedOut();
+    decRate = gyro.decRate;
     mustPerformStartup = gyro.performStartup;
   }
   if (mode == acs::SimpleSensorMode::OFF) {
     return;
   }
-  if (not cdHasTimedOut) {
-    return;
-  }
   if (mustPerformStartup) {
+    adis1650x::prepareWriteRegCommand(adis1650x::DEC_RATE_REG, decRate, cmdBuf.data(),
+                                      cmdBuf.size());
+    writeAdisReg(*gyro.cookie);
     uint8_t regList[6];
     // Read configuration
     regList[0] = adis1650x::DIAG_STAT_REG;
@@ -485,16 +571,23 @@ void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
       gyro.replyResult = returnvalue::FAILED;
       return;
     }
+    uint16_t decRateReadBack = (rawReply[10] << 8) | rawReply[11];
+    if (decRateReadBack != decRate) {
+      sif::warning << "AcsPollingTask: DEC rate configuration failed. Read " << decRateReadBack
+                   << ", expected " << decRate << std::endl;
+      gyro.replyResult = returnvalue::FAILED;
+    }
     MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
     gyro.ownReply.cfgWasSet = true;
     gyro.ownReply.cfg.diagStat = (rawReply[2] << 8) | rawReply[3];
     gyro.ownReply.cfg.filterSetting = (rawReply[4] << 8) | rawReply[5];
     gyro.ownReply.cfg.rangMdl = (rawReply[6] << 8) | rawReply[7];
     gyro.ownReply.cfg.mscCtrlReg = (rawReply[8] << 8) | rawReply[9];
-    gyro.ownReply.cfg.decRateReg = (rawReply[10] << 8) | rawReply[11];
+    gyro.ownReply.cfg.decRateReg = decRateReadBack;
     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 +626,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 +684,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 +702,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 +729,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 +800,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 +822,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/AcsBoardPolling.h

@@ -37,6 +37,7 @@ class AcsBoardPolling : public SystemObject,
 
   struct GyroAdis : public DevBase {
     adis1650x::Type type;
+    uint16_t decRate;
     Countdown countdown;
     acs::Adis1650XReply ownReply;
     acs::Adis1650XReply readerReply;
@@ -84,6 +85,8 @@ class AcsBoardPolling : public SystemObject,
   void gyroAdisHandler(GyroAdis& gyro);
   void mgmLis3Handler(MgmLis3& mgm);
   void mgmRm3100Handler(MgmRm3100& mgm);
+  // This fumction configures the register as specified on p.21 of the datasheet.
+  ReturnValue_t writeAdisReg(SpiCookie& cookie);
   // Special readout: 16us stall time between small 2 byte transfers.
   ReturnValue_t readAdisCfg(SpiCookie& spiCookie, size_t transferLen);
 };

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;
 }
 

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.h

@@ -22,6 +22,7 @@ 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;

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) {
@@ -89,7 +93,7 @@ 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) {
@@ -125,6 +129,7 @@ ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
   }
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::UPLOAD_IMAGE;
   }
   semaphore.release();
@@ -151,6 +156,7 @@ ReturnValue_t StrComHandler::startImageDownload(std::string path) {
   downloadImage.path = path;
   {
     MutexGuard mg(lock);
+    replyWasReceived = false;
     state = InternalState::DOWNLOAD_IMAGE;
   }
   terminate = false;
@@ -187,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();
@@ -216,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();
@@ -301,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;
@@ -323,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;
     }
@@ -342,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) {
@@ -349,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);
@@ -390,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;
@@ -412,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) {
@@ -435,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);

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;

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 284 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-04 13:59:07
+ * Generated on: 2023-06-21 19:01:02
  */
 #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";
@@ -193,6 +197,10 @@ const char *MPSOC_EXE_INVALID_APID_STRING = "MPSOC_EXE_INVALID_APID";
 const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
 const char *MPSOC_TM_SIZE_ERROR_STRING = "MPSOC_TM_SIZE_ERROR";
 const char *MPSOC_TM_CRC_MISSMATCH_STRING = "MPSOC_TM_CRC_MISSMATCH";
+const char *MPSOC_FLASH_READ_PACKET_ERROR_STRING = "MPSOC_FLASH_READ_PACKET_ERROR";
+const char *MPSOC_FLASH_READ_FAILED_STRING = "MPSOC_FLASH_READ_FAILED";
+const char *MPSOC_FLASH_READ_SUCCESSFUL_STRING = "MPSOC_FLASH_READ_SUCCESSFUL";
+const char *MPSOC_READ_TIMEOUT_STRING = "MPSOC_READ_TIMEOUT";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@@ -266,7 +274,10 @@ 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 *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -274,6 +285,7 @@ const char *OBC_OVERHEATING_STRING = "OBC_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 +489,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 +617,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):
@@ -668,6 +688,14 @@ const char *translateEvents(Event event) {
       return MPSOC_TM_SIZE_ERROR_STRING;
     case (12613):
       return MPSOC_TM_CRC_MISSMATCH_STRING;
+    case (12614):
+      return MPSOC_FLASH_READ_PACKET_ERROR_STRING;
+    case (12615):
+      return MPSOC_FLASH_READ_FAILED_STRING;
+    case (12616):
+      return MPSOC_FLASH_READ_SUCCESSFUL_STRING;
+    case (12617):
+      return MPSOC_READ_TIMEOUT_STRING;
     case (12700):
       return TRANSITION_BACK_TO_OFF_STRING;
     case (12701):
@@ -815,7 +843,13 @@ 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 (14013):
+      return FIRMWARE_INFO_STRING;
     case (14100):
       return NO_VALID_SENSOR_TEMPERATURE_STRING;
     case (14101):
@@ -830,6 +864,8 @@ const char *translateEvents(Event event) {
       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

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

linux/ipcore/PapbVcInterface.cpp

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

linux/ipcore/PapbVcInterface.h

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

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/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/CMakeLists.txt

@@ -2,7 +2,8 @@ target_sources(
   ${OBSW_NAME}
   PUBLIC PlocMemoryDumper.cpp
          PlocMpsocHandler.cpp
-         PlocMpsocHelper.cpp
+         PlocMpsocSpecialComHelper.cpp
+         plocMpsocHelpers.cpp
          PlocSupervisorHandler.cpp
          PlocSupvUartMan.cpp
          ScexDleParser.cpp

linux/payload/PlocMpsocHandler.h

@@ -1,9 +1,9 @@
 #ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 
-#include <linux/payload/PlocMpsocHelper.h>
+#include <linux/payload/PlocMpsocSpecialComHelper.h>
 #include <linux/payload/mpsocRetvals.h>
-#include <linux/payload/plocMpscoDefs.h>
+#include <linux/payload/plocMpsocHelpers.h>
 #include <linux/payload/plocSupvDefs.h>
 
 #include <string>
@@ -28,9 +28,10 @@
  * @note The sequence count in the space packets must be incremented with each received and sent
  *       packet otherwise the MPSoC will reply with an acknowledgment failure report.
  *
- * @author	J. Meier
+ * NOTE: This is not an example for a good device handler, DO NOT USE THIS AS A REFERENCE HANDLER.
+ * @author	J. Meier, R. Mueller
  */
-class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
+class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  public:
   /**
    * @brief Constructor
@@ -43,10 +44,10 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    *                            module in the programmable logic
    * @param supervisorHandler   Object ID of the supervisor handler
    */
-  PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
-                   PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch,
+  PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
+                   PlocMpsocSpecialComHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch,
                    object_id_t supervisorHandler);
-  virtual ~PlocMPSoCHandler();
+  virtual ~PlocMpsocHandler();
   virtual ReturnValue_t initialize() override;
   ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override;
@@ -77,7 +78,9 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
                                       uint8_t expectedReplies = 1, bool useAlternateId = false,
                                       DeviceCommandId_t alternateReplyID = 0) override;
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
-  virtual ReturnValue_t doSendReadHook() override;
+  ReturnValue_t doSendReadHook() override;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+  bool dontCheckQueue() override;
 
  private:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
@@ -103,7 +106,8 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   static const uint16_t APID_MASK = 0x7FF;
   static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
-  static const uint8_t STATUS_OFFSET = 10;
+
+  mpsoc::HkReport hkReport;
 
   MessageQueueIF* eventQueue = nullptr;
   MessageQueueIF* commandActionHelperQueue = nullptr;
@@ -114,6 +118,41 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   SpacePacketCreator creator;
   ploc::SpTcParams spParams = ploc::SpTcParams(creator);
 
+  PoolEntry<uint32_t> peStatus = PoolEntry<uint32_t>();
+  PoolEntry<uint8_t> peMode = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkPwrOn = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkReplyActive = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkJesdSyncStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkDacStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraSdiStatus = PoolEntry<uint8_t>();
+  PoolEntry<float> peCameraFpgaTemp = PoolEntry<float>();
+  PoolEntry<float> peCameraSocTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccInt = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccAux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccBram = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPaux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPint = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPdro = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb1V8 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc5V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3VA = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc2V5DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc1V2DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V9 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V6VTT = PoolEntry<float>();
+  PoolEntry<float> peSysmonSafeCotsCur = PoolEntry<float>();
+  PoolEntry<float> peSysmonNvm4XoCur = PoolEntry<float>();
+  PoolEntry<uint16_t> peSemUncorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint16_t> peSemCorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint8_t> peSemStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peRebootMpsocRequired = PoolEntry<uint8_t>();
+
   /**
    * This variable is used to store the id of the next reply to receive. This is necessary
    * because the PLOC sends as reply to each command at least one acknowledgment and execution
@@ -123,13 +162,14 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   SerialComIF* uartComIf = nullptr;
 
-  PlocMPSoCHelper* plocMPSoCHelper = nullptr;
+  PlocMpsocSpecialComHelper* specialComHelper = nullptr;
   Gpio uartIsolatorSwitch;
   object_id_t supervisorHandler = 0;
   CommandActionHelper commandActionHelper;
 
   // Used to block incoming commands when MPSoC helper class is currently executing a command
-  bool plocMPSoCHelperExecuting = false;
+  bool specialComHelperExecuting = false;
+  bool commandIsPending = false;
 
   struct TmMemReadReport {
     static const uint8_t FIX_SIZE = 14;
@@ -137,20 +177,18 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   };
 
   TmMemReadReport tmMemReadReport;
-
-  struct TmCamCmdRpt {
-    size_t rememberSpacePacketSize = 0;
-  };
-
-  TmCamCmdRpt tmCamCmdRpt;
+  Countdown cmdCountdown = Countdown(10000);
 
   struct TelemetryBuffer {
     uint16_t length = 0;
     uint8_t buffer[mpsoc::SP_MAX_SIZE];
   };
 
+  size_t foundPacketLen = 0;
   TelemetryBuffer tmBuffer;
+  uint32_t waitCycles = 0;
 
+  enum class StartupState { IDLE, HW_INIT, WAIT_CYCLES, DONE } startupState = StartupState::IDLE;
   enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };
 
   PowerState powerState = PowerState::OFF;
@@ -167,6 +205,8 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   ReturnValue_t prepareTcReplayStop();
   ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcDownlinkPwrOff();
+  ReturnValue_t prepareTcGetHkReport();
+  ReturnValue_t prepareTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcModeIdle();
@@ -174,7 +214,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   ReturnValue_t prepareTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcModeSnapshot();
-  void finishTcPrep(size_t packetLen);
+  ReturnValue_t finishTcPrep(mpsoc::TcBase& tcBase);
 
   /**
    * @brief   This function checks the crc of the received PLOC reply.
@@ -213,6 +253,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    */
   ReturnValue_t handleMemoryReadReport(const uint8_t* data);
 
+  ReturnValue_t handleGetHkReport(const uint8_t* data);
   ReturnValue_t handleCamCmdRpt(const uint8_t* data);
 
   /**
@@ -231,7 +272,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    * @param dataSize  Size of telemetry in bytes.
    * @param replyId   Id of the reply. This will be added to the ActionMessage.
    */
-  void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
+  void handleDeviceTm(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
 
   /**
    * @brief   In case an acknowledgment failure reply has been received this function disables
@@ -255,15 +296,11 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    */
   void disableExeReportReply();
 
-  void printStatus(const uint8_t* data);
-
   ReturnValue_t prepareTcModeReplay();
 
-  uint16_t getStatus(const uint8_t* data);
+  void cmdDoneHandler(bool success, ReturnValue_t result);
 
   void handleActionCommandFailure(ActionId_t actionId);
-
-  std::string getStatusString(uint16_t status);
 };
 
 #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */

linux/payload/PlocMpsocHelper.cpp

@@ -1,355 +0,0 @@
-#include <linux/payload/PlocMpsocHelper.h>
-
-#include <filesystem>
-#include <fstream>
-
-#ifdef XIPHOS_Q7S
-#include "bsp_q7s/fs/FilesystemHelper.h"
-#endif
-
-#include "mission/utility/Timestamp.h"
-
-using namespace ploc;
-
-PlocMPSoCHelper::PlocMPSoCHelper(object_id_t objectId) : SystemObject(objectId) {
-  spParams.buf = commandBuffer;
-  spParams.maxSize = sizeof(commandBuffer);
-}
-
-PlocMPSoCHelper::~PlocMPSoCHelper() {}
-
-ReturnValue_t PlocMPSoCHelper::initialize() {
-#ifdef XIPHOS_Q7S
-  sdcMan = SdCardManager::instance();
-  if (sdcMan == nullptr) {
-    sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl;
-    return returnvalue::FAILED;
-  }
-#endif
-  return returnvalue::OK;
-}
-
-ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
-  ReturnValue_t result = returnvalue::OK;
-  semaphore.acquire();
-  while (true) {
-#if OBSW_THREAD_TRACING == 1
-    trace::threadTrace(opCounter, "PLOC MPSOC Helper");
-#endif
-    switch (internalState) {
-      case InternalState::IDLE: {
-        semaphore.acquire();
-        break;
-      }
-      case InternalState::FLASH_WRITE: {
-        result = performFlashWrite();
-        if (result == returnvalue::OK) {
-          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL);
-        } else {
-          triggerEvent(MPSOC_FLASH_WRITE_FAILED);
-        }
-        internalState = InternalState::IDLE;
-        break;
-      }
-      default:
-        sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl;
-        break;
-    }
-  }
-}
-
-ReturnValue_t PlocMPSoCHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
-  if (uartComIF == nullptr) {
-    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
-}
-
-void PlocMPSoCHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
-
-void PlocMPSoCHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
-  sequenceCount = sequenceCount_;
-}
-
-ReturnValue_t PlocMPSoCHelper::startFlashWrite(std::string obcFile, std::string mpsocFile) {
-  ReturnValue_t result = returnvalue::OK;
-#ifdef XIPHOS_Q7S
-  result = FilesystemHelper::checkPath(obcFile);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = FilesystemHelper::fileExists(mpsocFile);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-#endif
-#ifdef TE0720_1CFA
-  if (not std::filesystem::exists(obcFile)) {
-    sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist"
-                 << std::endl;
-    return returnvalue::FAILED;
-  }
-#endif
-
-  flashWrite.obcFile = obcFile;
-  flashWrite.mpsocFile = mpsocFile;
-  internalState = InternalState::FLASH_WRITE;
-  result = resetHelper();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHelper::resetHelper() {
-  ReturnValue_t result = returnvalue::OK;
-  semaphore.release();
-  spParams.buf = commandBuffer;
-  terminate = false;
-  result = uartComIF->flushUartRxBuffer(comCookie);
-  return result;
-}
-
-void PlocMPSoCHelper::stopProcess() { terminate = true; }
-
-ReturnValue_t PlocMPSoCHelper::performFlashWrite() {
-  ReturnValue_t result = returnvalue::OK;
-  result = flashfopen();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  uint8_t tempData[mpsoc::MAX_DATA_SIZE];
-  std::ifstream file(flashWrite.obcFile, std::ifstream::binary);
-  // Set position of next character to end of file input stream
-  file.seekg(0, file.end);
-  // tellg returns position of character in input stream
-  size_t remainingSize = file.tellg();
-  size_t dataLength = 0;
-  size_t bytesRead = 0;
-  while (remainingSize > 0) {
-    if (terminate) {
-      return returnvalue::OK;
-    }
-    if (remainingSize > mpsoc::MAX_DATA_SIZE) {
-      dataLength = mpsoc::MAX_DATA_SIZE;
-    } else {
-      dataLength = remainingSize;
-    }
-    if (file.is_open()) {
-      file.seekg(bytesRead, file.beg);
-      file.read(reinterpret_cast<char*>(tempData), dataLength);
-      bytesRead += dataLength;
-      remainingSize -= dataLength;
-    } else {
-      return FILE_CLOSED_ACCIDENTALLY;
-    }
-    (*sequenceCount)++;
-    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
-    result = tc.buildPacket(tempData, dataLength);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = handlePacketTransmission(tc);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-  result = flashfclose();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHelper::flashfopen() {
-  ReturnValue_t result = returnvalue::OK;
-  spParams.buf = commandBuffer;
-  (*sequenceCount)++;
-  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
-  result = flashFopen.createPacket(flashWrite.mpsocFile, mpsoc::FlashFopen::APPEND);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = handlePacketTransmission(flashFopen);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t PlocMPSoCHelper::flashfclose() {
-  ReturnValue_t result = returnvalue::OK;
-  spParams.buf = commandBuffer;
-  (*sequenceCount)++;
-  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
-  result = flashFclose.createPacket(flashWrite.mpsocFile);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = handlePacketTransmission(flashFclose);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t PlocMPSoCHelper::handlePacketTransmission(ploc::SpTcBase& tc) {
-  ReturnValue_t result = returnvalue::OK;
-  result = sendCommand(tc);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = handleAck();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = handleExe();
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t PlocMPSoCHelper::sendCommand(ploc::SpTcBase& tc) {
-  ReturnValue_t result = returnvalue::OK;
-  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
-  if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
-    triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
-    return result;
-  }
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHelper::handleAck() {
-  ReturnValue_t result = returnvalue::OK;
-  result = handleTmReception(mpsoc::SIZE_ACK_REPORT);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  SpTmReader tmPacket(tmBuf.data(), tmBuf.size());
-  result = checkReceivedTm(tmPacket);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  uint16_t apid = tmPacket.getApid();
-  if (apid != mpsoc::apid::ACK_SUCCESS) {
-    handleAckApidFailure(apid);
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
-}
-
-void PlocMPSoCHelper::handleAckApidFailure(uint16_t apid) {
-  if (apid == mpsoc::apid::ACK_FAILURE) {
-    triggerEvent(MPSOC_ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState));
-    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Received acknowledgement failure "
-                 << "report" << std::endl;
-  } else {
-    triggerEvent(MPSOC_ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
-    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report "
-                 << "but received space packet with apid " << std::hex << apid << std::endl;
-  }
-}
-
-ReturnValue_t PlocMPSoCHelper::handleExe() {
-  ReturnValue_t result = returnvalue::OK;
-
-  result = handleTmReception(mpsoc::SIZE_EXE_REPORT);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  ploc::SpTmReader tmPacket(tmBuf.data(), tmBuf.size());
-  result = checkReceivedTm(tmPacket);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  uint16_t apid = tmPacket.getApid();
-  if (apid != mpsoc::apid::EXE_SUCCESS) {
-    handleExeApidFailure(apid);
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
-}
-
-void PlocMPSoCHelper::handleExeApidFailure(uint16_t apid) {
-  if (apid == mpsoc::apid::EXE_FAILURE) {
-    triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
-    sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Received execution failure "
-                 << "report" << std::endl;
-  } else {
-    triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
-    sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Expected execution report "
-                 << "but received space packet with apid " << std::hex << apid << std::endl;
-  }
-}
-
-ReturnValue_t PlocMPSoCHelper::handleTmReception(size_t remainingBytes) {
-  ReturnValue_t result = returnvalue::OK;
-  size_t readBytes = 0;
-  size_t currentBytes = 0;
-  for (int retries = 0; retries < RETRIES; retries++) {
-    result = receive(tmBuf.data() + readBytes, &currentBytes, remainingBytes);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    readBytes += currentBytes;
-    remainingBytes = remainingBytes - currentBytes;
-    if (remainingBytes == 0) {
-      break;
-    }
-  }
-  if (remainingBytes != 0) {
-    sif::warning << "PlocMPSoCHelper::handleTmReception: Failed to receive reply" << std::endl;
-    triggerEvent(MPSOC_MISSING_EXE, remainingBytes, static_cast<uint32_t>(internalState));
-    return returnvalue::FAILED;
-  }
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHelper::checkReceivedTm(SpTmReader& reader) {
-  ReturnValue_t result = reader.checkSize();
-  if (result != returnvalue::OK) {
-    sif::error << "PlocMPSoCHelper::handleTmReception: Size check on received TM failed"
-               << std::endl;
-    triggerEvent(MPSOC_TM_SIZE_ERROR);
-    return result;
-  }
-  reader.checkCrc();
-  if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::handleTmReception: CRC check failed" << std::endl;
-    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
-    return result;
-  }
-  (*sequenceCount)++;
-  uint16_t recvSeqCnt = reader.getSequenceCount();
-  if (recvSeqCnt != *sequenceCount) {
-    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
-    *sequenceCount = recvSeqCnt;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t PlocMPSoCHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) {
-  ReturnValue_t result = returnvalue::OK;
-  uint8_t* buffer = nullptr;
-  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
-  if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
-    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
-                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
-    return returnvalue::FAILED;
-  }
-  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
-  if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
-    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
-    return returnvalue::FAILED;
-  }
-  if (*readBytes > 0) {
-    std::memcpy(data, buffer, *readBytes);
-  }
-  return result;
-}

linux/payload/PlocMpsocSpecialComHelper.cpp

@@ -0,0 +1,544 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <linux/payload/PlocMpsocSpecialComHelper.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+
+#ifdef XIPHOS_Q7S
+#include "bsp_q7s/fs/FilesystemHelper.h"
+#endif
+
+#include "mission/utility/Timestamp.h"
+
+using namespace ploc;
+
+PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId)
+    : SystemObject(objectId) {
+  spParams.buf = commandBuffer;
+  spParams.maxSize = sizeof(commandBuffer);
+}
+
+PlocMpsocSpecialComHelper::~PlocMpsocSpecialComHelper() {}
+
+ReturnValue_t PlocMpsocSpecialComHelper::initialize() {
+#ifdef XIPHOS_Q7S
+  sdcMan = SdCardManager::instance();
+  if (sdcMan == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl;
+    return returnvalue::FAILED;
+  }
+#endif
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode) {
+  ReturnValue_t result = returnvalue::OK;
+  semaphore.acquire();
+  while (true) {
+#if OBSW_THREAD_TRACING == 1
+    trace::threadTrace(opCounter, "PLOC MPSOC Helper");
+#endif
+    switch (internalState) {
+      case InternalState::IDLE: {
+        semaphore.acquire();
+        break;
+      }
+      case InternalState::FLASH_WRITE: {
+        result = performFlashWrite();
+        if (result == returnvalue::OK) {
+          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, sequenceCount->get());
+        } else {
+          triggerEvent(MPSOC_FLASH_WRITE_FAILED, sequenceCount->get());
+        }
+        internalState = InternalState::IDLE;
+        break;
+      }
+      case InternalState::FLASH_READ: {
+        result = performFlashRead();
+        if (result == returnvalue::OK) {
+          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, sequenceCount->get());
+        } else {
+          triggerEvent(MPSOC_FLASH_READ_FAILED, sequenceCount->get());
+        }
+        internalState = InternalState::IDLE;
+        break;
+      }
+      default:
+        sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl;
+        break;
+    }
+  }
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
+  if (uartComIF == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
+
+void PlocMpsocSpecialComHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
+  sequenceCount = sequenceCount_;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::startFlashWrite(std::string obcFile,
+                                                         std::string mpsocFile) {
+  if (internalState != InternalState::IDLE) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  internalState = InternalState::FLASH_WRITE;
+  return semaphore.release();
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::startFlashRead(std::string obcFile, std::string mpsocFile,
+                                                        size_t readFileSize) {
+  if (internalState != InternalState::IDLE) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  flashReadAndWrite.totalReadSize = readFileSize;
+  internalState = InternalState::FLASH_READ;
+  return semaphore.release();
+}
+
+void PlocMpsocSpecialComHelper::resetHelper() {
+  spParams.buf = commandBuffer;
+  terminate = false;
+  uartComIF->flushUartRxBuffer(comCookie);
+}
+
+void PlocMpsocSpecialComHelper::stopProcess() { terminate = true; }
+
+ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
+  ReturnValue_t result = returnvalue::OK;
+  std::ifstream file(flashReadAndWrite.obcFile, std::ifstream::binary);
+  if (file.bad()) {
+    return returnvalue::FAILED;
+  }
+  result = flashfopen(mpsoc::FileAccessModes::WRITE | mpsoc::FileAccessModes::OPEN_ALWAYS);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Set position of next character to end of file input stream
+  file.seekg(0, file.end);
+  // tellg returns position of character in input stream
+  size_t remainingSize = file.tellg();
+  size_t dataLength = 0;
+  size_t bytesRead = 0;
+  while (remainingSize > 0) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    // The minus 4 is necessary for unknown reasons. Maybe some bug in the ILH software?
+    if (remainingSize > mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4) {
+      dataLength = mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4;
+    } else {
+      dataLength = remainingSize;
+    }
+    if (file.bad() or not file.is_open()) {
+      return FILE_WRITE_ERROR;
+    }
+    file.seekg(bytesRead, file.beg);
+    file.read(reinterpret_cast<char*>(fileBuf.data()), dataLength);
+    bytesRead += dataLength;
+    remainingSize -= dataLength;
+    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
+    result = tc.setPayload(fileBuf.data(), dataLength);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = tc.finishPacket();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    (*sequenceCount)++;
+    result = handlePacketTransmissionNoReply(tc);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  result = flashfclose();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
+  std::error_code e;
+  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
+  if (ofile.bad()) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
+  if (result != returnvalue::OK) {
+    std::filesystem::remove(flashReadAndWrite.obcFile, e);
+    return result;
+  }
+  size_t readSoFar = 0;
+  size_t nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
+  while (readSoFar < flashReadAndWrite.totalReadSize) {
+    if (terminate) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return returnvalue::OK;
+    }
+    nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
+    if (flashReadAndWrite.totalReadSize - readSoFar < mpsoc::MAX_FLASH_READ_DATA_SIZE) {
+      nextReadSize = flashReadAndWrite.totalReadSize - readSoFar;
+    }
+    if (ofile.bad() or not ofile.is_open()) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return FILE_READ_ERROR;
+    }
+    mpsoc::TcFlashRead flashReadRequest(spParams, *sequenceCount);
+    result = flashReadRequest.setPayload(nextReadSize);
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    result = flashReadRequest.finishPacket();
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    (*sequenceCount)++;
+    result = handlePacketTransmissionFlashRead(flashReadRequest, ofile, nextReadSize);
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    readSoFar += nextReadSize;
+  }
+  result = flashfclose();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
+  spParams.buf = commandBuffer;
+  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
+  ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = flashFopen.finishPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  (*sequenceCount)++;
+  result = handlePacketTransmissionNoReply(flashFopen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::flashfclose() {
+  spParams.buf = commandBuffer;
+  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
+  ReturnValue_t result = flashFclose.finishPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  (*sequenceCount)++;
+  result = handlePacketTransmissionNoReply(flashFclose);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc,
+                                                                           std::ofstream& ofile,
+                                                                           size_t expectedReadLen) {
+  ReturnValue_t result = sendCommand(tc);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  // We have the nominal case where the flash read report appears first, or the case where we
+  // get an EXE failure immediately.
+  if (spReader.getApid() == mpsoc::apid::TM_FLASH_READ_REPORT) {
+    result = handleFlashReadReply(ofile, expectedReadLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    return handleExe();
+  } else if (spReader.getApid() == mpsoc::apid::EXE_FAILURE) {
+    handleExeFailure();
+  } else {
+    triggerEvent(MPSOC_EXE_INVALID_APID, spReader.getApid(), static_cast<uint32_t>(internalState));
+    sif::warning << "PLOC MPSoC: Expected execution report "
+                 << "but received space packet with apid " << std::hex << spReader.getApid()
+                 << std::endl;
+  }
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionNoReply(ploc::SpTcBase& tc) {
+  ReturnValue_t result = sendCommand(tc);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return handleExe();
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::sendCommand(ploc::SpTcBase& tc) {
+  ReturnValue_t result = returnvalue::OK;
+  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
+    triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handleAck() {
+  ReturnValue_t result = returnvalue::OK;
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid != mpsoc::apid::ACK_SUCCESS) {
+    handleAckApidFailure(spReader);
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelper::handleAckApidFailure(const ploc::SpTmReader& reader) {
+  uint16_t apid = reader.getApid();
+  if (apid == mpsoc::apid::ACK_FAILURE) {
+    uint16_t status = mpsoc::getStatusFromRawData(reader.getFullData());
+    sif::warning << "PLOC MPSoC ACK Failure: " << mpsoc::getStatusString(status) << std::endl;
+    triggerEvent(MPSOC_ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState), status);
+  } else {
+    triggerEvent(MPSOC_ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handleExe() {
+  ReturnValue_t result = returnvalue::OK;
+
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid == mpsoc::apid::EXE_FAILURE) {
+    handleExeFailure();
+    return returnvalue::FAILED;
+  } else if (apid != mpsoc::apid::EXE_SUCCESS) {
+    triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PLOC MPSoC: Expected execution report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelper::handleExeFailure() {
+  uint16_t status = mpsoc::getStatusFromRawData(spReader.getFullData());
+  sif::warning << "PLOC MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
+  triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
+  ReturnValue_t result = returnvalue::OK;
+  tmCountdown.resetTimer();
+  size_t readBytes = 0;
+  size_t currentBytes = 0;
+  uint32_t usleepDelay = 5;
+  size_t fullPacketLen = 0;
+  while (true) {
+    if (tmCountdown.hasTimedOut()) {
+      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
+      return returnvalue::FAILED;
+    }
+    result = receive(tmBuf.data() + readBytes, 6, &currentBytes);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    spReader.setReadOnlyData(tmBuf.data(), tmBuf.size());
+    fullPacketLen = spReader.getFullPacketLen();
+    readBytes += currentBytes;
+    if (readBytes == 6) {
+      break;
+    }
+    usleep(usleepDelay);
+    if (usleepDelay < 200000) {
+      usleepDelay *= 4;
+    }
+  }
+  while (true) {
+    if (tmCountdown.hasTimedOut()) {
+      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
+      return returnvalue::FAILED;
+    }
+    result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
+    readBytes += currentBytes;
+    if (fullPacketLen == readBytes) {
+      break;
+    }
+    usleep(usleepDelay);
+    if (usleepDelay < 200000) {
+      usleepDelay *= 4;
+    }
+  }
+  // arrayprinter::print(tmBuf.data(), readBytes);
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::handleFlashReadReply(std::ofstream& ofile,
+                                                              size_t expectedReadLen) {
+  ReturnValue_t result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid != mpsoc::apid::TM_FLASH_READ_REPORT) {
+    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_APID_ERROR);
+    sif::warning << "PLOC MPSoC Flash Read: Unexpected APID" << std::endl;
+    return result;
+  }
+  const uint8_t* packetData = spReader.getPacketData();
+  size_t deserDummy = spReader.getPacketDataLen() - mpsoc::CRC_SIZE;
+  uint32_t receivedReadLen = 0;
+  // I think this is buggy, weird stuff in the short name field.
+  //  std::string receivedShortName = std::string(reinterpret_cast<const char*>(packetData), 12);
+  //  if (receivedShortName != flashReadAndWrite.mpsocFile.substr(0, 11)) {
+  //    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request file name and "
+  //                    "received file name"
+  //                 << std::endl;
+  //    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_FILENAME_ERROR);
+  //    return returnvalue::FAILED;
+  //  }
+  packetData += 12;
+  result = SerializeAdapter::deSerialize(&receivedReadLen, &packetData, &deserDummy,
+                                         SerializeIF::Endianness::NETWORK);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  if (receivedReadLen != expectedReadLen) {
+    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request read length and "
+                    "received read length"
+                 << std::endl;
+    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_READLEN_ERROR);
+    return returnvalue::FAILED;
+  }
+  ofile.write(reinterpret_cast<const char*>(packetData), receivedReadLen);
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::fileCheck(std::string obcFile) {
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = FilesystemHelper::checkPath(obcFile);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#elif defined(TE0720_1CFA)
+  if (not std::filesystem::exists(obcFile)) {
+    sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist"
+                 << std::endl;
+    return returnvalue::FAILED;
+  }
+#endif
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::startFlashReadOrWriteBase(std::string obcFile,
+                                                                   std::string mpsocFile) {
+  ReturnValue_t result = fileCheck(obcFile);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  flashReadAndWrite.obcFile = std::move(obcFile);
+  flashReadAndWrite.mpsocFile = std::move(mpsocFile);
+  resetHelper();
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() {
+  ReturnValue_t result = spReader.checkSize();
+  if (result != returnvalue::OK) {
+    sif::error << "PLOC MPSoC: Size check on received TM failed" << std::endl;
+    triggerEvent(MPSOC_TM_SIZE_ERROR);
+    return result;
+  }
+  spReader.checkCrc();
+  if (result != returnvalue::OK) {
+    sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
+    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
+    return result;
+  }
+  uint16_t recvSeqCnt = spReader.getSequenceCount();
+  if (recvSeqCnt != *sequenceCount) {
+    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
+    *sequenceCount = recvSeqCnt;
+  }
+  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
+  (*sequenceCount)++;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelper::receive(uint8_t* data, size_t requestBytes,
+                                                 size_t* readBytes) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t* buffer = nullptr;
+  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
+    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
+                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
+    return returnvalue::FAILED;
+  }
+  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
+    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
+    return returnvalue::FAILED;
+  }
+  if (*readBytes > 0) {
+    std::memcpy(data, buffer, *readBytes);
+  }
+  return result;
+}

linux/payload/PlocMpsocSpecialComHelper.h

@@ -1,11 +1,12 @@
 #ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
 #define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
 
-#include <linux/payload/plocMpscoDefs.h>
+#include <linux/payload/plocMpsocHelpers.h>
 #include <mission/utility/trace.h>
 
 #include <string>
 
+#include "OBSWConfig.h"
 #include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
@@ -22,14 +23,14 @@
  *          MPSoC and OBC.
  * @author  J. Meier
  */
-class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
+class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF {
  public:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER;
 
   //! [EXPORT] : [COMMENT] Flash write fails
   static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
   //! [EXPORT] : [COMMENT] Flash write successful
-  static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::LOW);
+  static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::INFO);
   //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command
   //! to the MPSoC
   //! P1: Return value returned by the communication interface sendMessage function
@@ -71,9 +72,19 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
   static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
   static const Event MPSOC_TM_SIZE_ERROR = MAKE_EVENT(12, severity::LOW);
   static const Event MPSOC_TM_CRC_MISSMATCH = MAKE_EVENT(13, severity::LOW);
+  static const Event MPSOC_FLASH_READ_PACKET_ERROR = MAKE_EVENT(14, severity::LOW);
+  static const Event MPSOC_FLASH_READ_FAILED = MAKE_EVENT(15, severity::LOW);
+  static const Event MPSOC_FLASH_READ_SUCCESSFUL = MAKE_EVENT(16, severity::INFO);
+  static const Event MPSOC_READ_TIMEOUT = MAKE_EVENT(17, severity::LOW);
 
-  PlocMPSoCHelper(object_id_t objectId);
-  virtual ~PlocMPSoCHelper();
+  enum FlashReadErrorType : uint32_t {
+    FLASH_READ_APID_ERROR = 0,
+    FLASH_READ_FILENAME_ERROR = 1,
+    FLASH_READ_READLEN_ERROR = 2
+  };
+
+  PlocMpsocSpecialComHelper(object_id_t objectId);
+  virtual ~PlocMpsocSpecialComHelper();
 
   ReturnValue_t initialize() override;
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
@@ -90,6 +101,14 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
    * @return  returnvalue::OK if successful, otherwise error return value
    */
   ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile);
+  /**
+   *
+   * @param obcFile Full target file name on OBC
+   * @param mpsocFile The file on the MPSoC which should be copied ot the OBC
+   * @param readFileSize The size of the file on the MPSoC.
+   * @return
+   */
+  ReturnValue_t startFlashRead(std::string obcFile, std::string mpsocFile, size_t readFileSize);
 
   /**
    * @brief   Can be used to interrupt a running data transfer.
@@ -104,20 +123,25 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
 
-  //! [EXPORT] : [COMMENT] File accidentally close
-  static const ReturnValue_t FILE_CLOSED_ACCIDENTALLY = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] File error occured for file transfers from OBC to the MPSoC.
+  static const ReturnValue_t FILE_WRITE_ERROR = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] File error occured for file transfers from MPSoC to OBC.
+  static const ReturnValue_t FILE_READ_ERROR = MAKE_RETURN_CODE(0xA1);
 
   // Maximum number of times the communication interface retries polling data from the reply
   // buffer
   static const int RETRIES = 10000;
 
-  struct FlashWrite {
+  struct FlashInfo {
     std::string obcFile;
     std::string mpsocFile;
   };
 
-  struct FlashWrite flashWrite;
+  struct FlashRead : public FlashInfo {
+    size_t totalReadSize = 0;
+  };
 
+  struct FlashRead flashReadAndWrite;
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
 #endif
@@ -134,7 +158,10 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
   SpacePacketCreator creator;
   ploc::SpTcParams spParams = ploc::SpTcParams(creator);
 
-  std::array<uint8_t, mpsoc::MAX_REPLY_SIZE> tmBuf;
+  Countdown tmCountdown = Countdown(5000);
+
+  std::array<uint8_t, mpsoc::SP_MAX_DATA_SIZE> fileBuf{};
+  std::array<uint8_t, mpsoc::MAX_REPLY_SIZE> tmBuf{};
 
   bool terminate = false;
 
@@ -147,20 +174,27 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {
   CookieIF* comCookie = nullptr;
   // Sequence count, must be set by Ploc MPSoC Handler
   SourceSequenceCounter* sequenceCount = nullptr;
+  ploc::SpTmReader spReader;
 
-  ReturnValue_t resetHelper();
+  void resetHelper();
   ReturnValue_t performFlashWrite();
-  ReturnValue_t flashfopen();
+  ReturnValue_t performFlashRead();
+  ReturnValue_t flashfopen(uint8_t accessMode);
   ReturnValue_t flashfclose();
-  ReturnValue_t handlePacketTransmission(ploc::SpTcBase& tc);
+  ReturnValue_t handlePacketTransmissionNoReply(ploc::SpTcBase& tc);
+  ReturnValue_t handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc, std::ofstream& ofile,
+                                                  size_t expectedReadLen);
+  ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
   ReturnValue_t sendCommand(ploc::SpTcBase& tc);
-  ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes);
+  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
   ReturnValue_t handleAck();
   ReturnValue_t handleExe();
-  void handleAckApidFailure(uint16_t apid);
-  void handleExeApidFailure(uint16_t apid);
-  ReturnValue_t handleTmReception(size_t remainingBytes);
-  ReturnValue_t checkReceivedTm(ploc::SpTmReader& reader);
+  ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
+  ReturnValue_t fileCheck(std::string obcFile);
+  void handleAckApidFailure(const ploc::SpTmReader& reader);
+  void handleExeFailure();
+  ReturnValue_t handleTmReception();
+  ReturnValue_t checkReceivedTm();
 };
 
 #endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */

linux/payload/PlocSupervisorHandler.cpp

@@ -151,7 +151,7 @@ void PlocSupervisorHandler::doStartUp() {
       }
     }
   }
-  if (startupState == StartupState::SET_TIME_EXECUTING) {
+  if (startupState == StartupState::TIME_WAS_SET) {
     startupState = StartupState::ON;
   }
   if (startupState == StartupState::ON) {
@@ -176,7 +176,7 @@ ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t*
 ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
   if (startupState == StartupState::SET_TIME) {
     *id = supv::SET_TIME_REF;
-    startupState = StartupState::SET_TIME_EXECUTING;
+    startupState = StartupState::WAIT_FOR_TIME_REPLY;
     return buildCommandFromCommand(*id, nullptr, 0);
   }
   return NOTHING_TO_SEND;
@@ -1909,6 +1909,10 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionRepor
     case supv::SET_TIME_REF: {
       // We could only allow proper bootup when the time was set successfully, but
       // this makes debugging difficult.
+
+      if (startupState == StartupState::WAIT_FOR_TIME_REPLY) {
+        startupState = StartupState::TIME_WAS_SET;
+      }
       break;
     }
     default:

linux/payload/PlocSupervisorHandler.h

@@ -99,7 +99,14 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   static const uint32_t MRAM_DUMP_TIMEOUT = 60000;
   // 4 s
   static const uint32_t BOOT_TIMEOUT = 4000;
-  enum class StartupState : uint8_t { OFF, BOOTING, SET_TIME, SET_TIME_EXECUTING, ON };
+  enum class StartupState : uint8_t {
+    OFF,
+    BOOTING,
+    SET_TIME,
+    WAIT_FOR_TIME_REPLY,
+    TIME_WAS_SET,
+    ON
+  };
 
   static constexpr bool SET_TIME_DURING_BOOT = true;
 

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();

linux/payload/plocMpsocHelpers.cpp

@@ -0,0 +1,95 @@
+#include "plocMpsocHelpers.h"
+
+uint16_t mpsoc::getStatusFromRawData(const uint8_t* data) {
+  return (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
+}
+std::string mpsoc::getStatusString(uint16_t status) {
+  switch (status) {
+    case (mpsoc::status_code::UNKNOWN_APID): {
+      return "Unknown APID";
+      break;
+    }
+    case (mpsoc::status_code::INCORRECT_LENGTH): {
+      return "Incorrect length";
+      break;
+    }
+    case (mpsoc::status_code::INCORRECT_CRC): {
+      return "Incorrect crc";
+      break;
+    }
+    case (mpsoc::status_code::INCORRECT_PKT_SEQ_CNT): {
+      return "Incorrect packet sequence count";
+      break;
+    }
+    case (mpsoc::status_code::TC_NOT_ALLOWED_IN_MODE): {
+      return "TC not allowed in this mode";
+      break;
+    }
+    case (mpsoc::status_code::TC_EXEUTION_DISABLED): {
+      return "TC execution disabled";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_MOUNT_FAILED): {
+      return "Flash mount failed";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_FILE_ALREADY_OPEN): {
+      return "Flash file already open";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_FILE_ALREADY_CLOSED): {
+      return "Flash file already closed";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_FILE_OPEN_FAILED): {
+      return "Flash file open failed";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_FILE_NOT_OPEN): {
+      return "Flash file not open";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_UNMOUNT_FAILED): {
+      return "Flash unmount failed";
+      break;
+    }
+    case (mpsoc::status_code::HEAP_ALLOCATION_FAILED): {
+      return "Heap allocation failed";
+      break;
+    }
+    case (mpsoc::status_code::INVALID_PARAMETER): {
+      return "Invalid parameter";
+      break;
+    }
+    case (mpsoc::status_code::NOT_INITIALIZED): {
+      return "Not initialized";
+      break;
+    }
+    case (mpsoc::status_code::REBOOT_IMMINENT): {
+      return "Reboot imminent";
+      break;
+    }
+    case (mpsoc::status_code::CORRUPT_DATA): {
+      return "Corrupt data";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_CORRECTABLE_MISMATCH): {
+      return "Flash correctable mismatch";
+      break;
+    }
+    case (mpsoc::status_code::FLASH_UNCORRECTABLE_MISMATCH): {
+      return "Flash uncorrectable mismatch";
+      break;
+    }
+    case (mpsoc::status_code::DEFAULT_ERROR_CODE): {
+      return "Default error code";
+      break;
+    }
+    default:
+      std::stringstream ss;
+      ss << "0x" << std::hex << status;
+      return ss.str().c_str();
+      break;
+  }
+  return "";
+}

linux/payload/plocMpsocHelpers.h

@@ -1,6 +1,7 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <linux/payload/mpsocRetvals.h>
 #include <mission/payload/plocSpBase.h>
@@ -12,6 +13,61 @@
 
 namespace mpsoc {
 
+enum FileAccessModes : uint8_t {
+  // Opens a file, fails if the file does not exist.
+  OPEN_EXISTING = 0x00,
+  READ = 0x01,
+  WRITE = 0x02,
+  // Creates a new file, fails if it already exists.
+  CREATE_NEW = 0x04,
+  // Creates a new file, existing file is truncated and overwritten.
+  CREATE_ALWAYS = 0x08,
+  // Opens the file if it is existing. If not, a new file is created.
+  OPEN_ALWAYS = 0x10,
+  OPEN_APPEND = 0x30
+};
+
+static constexpr uint32_t HK_SET_ID = 0;
+
+namespace poolid {
+enum {
+  STATUS = 0,
+  MODE = 1,
+  DOWNLINK_PWR_ON = 2,
+  DOWNLINK_REPLY_ACTIIVE = 3,
+  DOWNLINK_JESD_SYNC_STATUS = 4,
+  DOWNLINK_DAC_STATUS = 5,
+  CAM_STATUS = 6,
+  CAM_SDI_STATUS = 7,
+  CAM_FPGA_TEMP = 8,
+  CAM_SOC_TEMP = 9,
+  SYSMON_TEMP = 10,
+  SYSMON_VCCINT = 11,
+  SYSMON_VCCAUX = 12,
+  SYSMON_VCCBRAM = 13,
+  SYSMON_VCCPAUX = 14,
+  SYSMON_VCCPINT = 15,
+  SYSMON_VCCPDRO = 16,
+  SYSMON_MB12V = 17,
+  SYSMON_MB3V3 = 18,
+  SYSMON_MB1V8 = 19,
+  SYSMON_VCC12V = 20,
+  SYSMON_VCC5V = 21,
+  SYSMON_VCC3V3 = 22,
+  SYSMON_VCC3V3VA = 23,
+  SYSMON_VCC2V5DDR = 24,
+  SYSMON_VCC1V2DDR = 25,
+  SYSMON_VCC0V9 = 26,
+  SYSMON_VCC0V6VTT = 27,
+  SYSMON_SAFE_COTS_CUR = 28,
+  SYSMON_NVM4_XO_CUR = 29,
+  SEM_UNCORRECTABLE_ERRS = 30,
+  SEM_CORRECTABLE_ERRS = 31,
+  SEM_STATUS = 32,
+  REBOOT_MPSOC_REQUIRED = 33,
+};
+}
+
 static const DeviceCommandId_t NONE = 0;
 static const DeviceCommandId_t TC_MEM_WRITE = 1;
 static const DeviceCommandId_t TC_MEM_READ = 2;
@@ -20,7 +76,7 @@ static const DeviceCommandId_t EXE_REPORT = 5;
 static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6;
 static const DeviceCommandId_t TC_FLASHFOPEN = 7;
 static const DeviceCommandId_t TC_FLASHFCLOSE = 8;
-static const DeviceCommandId_t TC_FLASHWRITE = 9;
+static const DeviceCommandId_t TC_FLASH_WRITE_FULL_FILE = 9;
 static const DeviceCommandId_t TC_FLASHDELETE = 10;
 static const DeviceCommandId_t TC_REPLAY_START = 11;
 static const DeviceCommandId_t TC_REPLAY_STOP = 12;
@@ -37,6 +93,11 @@ static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
 static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
 static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
 static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
+static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
+static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
+static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
+static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
+static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;
 
 // Will reset the sequence count of the OBSW
 static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;
@@ -45,6 +106,7 @@ static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
 static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
 static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
+static constexpr size_t SIZE_TM_HK_REPORT = 369;
 
 /**
  * SpacePacket apids of PLOC telecommands and telemetry.
@@ -57,23 +119,32 @@ static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
 static const uint16_t TC_MEM_WRITE = 0x114;
 static const uint16_t TC_MEM_READ = 0x115;
 static const uint16_t TC_CAM_TAKE_PIC = 0x116;
-static const uint16_t TC_FLASHWRITE = 0x117;
+static constexpr uint16_t TC_FLASHWRITE = 0x117;
+static constexpr uint16_t TC_FLASHREAD = 0x118;
 static const uint16_t TC_FLASHFOPEN = 0x119;
 static const uint16_t TC_FLASHFCLOSE = 0x11A;
+static constexpr uint16_t TC_FLASH_GET_DIRECTORY_CONTENT = 0x11B;
 static const uint16_t TC_FLASHDELETE = 0x11C;
+static constexpr uint16_t TC_FLASH_CREATE_DIR = 0x11D;
 static const uint16_t TC_MODE_IDLE = 0x11E;
 static const uint16_t TC_MODE_REPLAY = 0x11F;
 static const uint16_t TC_MODE_SNAPSHOT = 0x120;
 static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121;
+static constexpr uint16_t TC_HK_GET_REPORT = 0x123;
 static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
 static const uint16_t TC_CAM_CMD_SEND = 0x12C;
+static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E;
 static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130;
-static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+
 static const uint16_t ACK_SUCCESS = 0x400;
 static const uint16_t ACK_FAILURE = 0x401;
 static const uint16_t EXE_SUCCESS = 0x402;
 static const uint16_t EXE_FAILURE = 0x403;
+static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+static const uint16_t TM_FLASH_READ_REPORT = 0x405;
+static constexpr uint16_t TM_FLASH_DIRECTORY_CONTENT = 0x406;
 static const uint16_t TM_CAM_CMD_RPT = 0x407;
+static constexpr uint16_t TM_HK_GET_REPORT = 0x408;
 }  // namespace apid
 
 /** Offset from first byte in space packet to first byte of data field */
@@ -83,6 +154,8 @@ static const char NULL_TERMINATOR = '\0';
 static const uint8_t MIN_SPACE_PACKET_LENGTH = 7;
 static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;
 
+static const uint8_t STATUS_OFFSET = 10;
+
 static constexpr size_t CRC_SIZE = 2;
 
 /**
@@ -106,9 +179,15 @@ static const uint16_t LENGTH_TC_MEM_READ = 8;
  * at sheet README
  */
 static constexpr size_t SP_MAX_SIZE = 1024;
-static const size_t MAX_REPLY_SIZE = SP_MAX_SIZE * 3;
-static const size_t MAX_COMMAND_SIZE = SP_MAX_SIZE;
-static const size_t MAX_DATA_SIZE = 1016;
+static constexpr size_t MAX_REPLY_SIZE = SP_MAX_SIZE * 3;
+static constexpr size_t MAX_COMMAND_SIZE = SP_MAX_SIZE;
+// 1016 bytes.
+static constexpr size_t SP_MAX_DATA_SIZE = SP_MAX_SIZE - ccsds::HEADER_LEN - CRC_SIZE;
+static constexpr size_t FLASH_READ_MIN_OVERHEAD = 16;
+// 1000 bytes.
+static const size_t MAX_FLASH_READ_DATA_SIZE = SP_MAX_DATA_SIZE - FLASH_READ_MIN_OVERHEAD;
+// 1012 bytes, 4 bytes for the write length.
+static constexpr size_t MAX_FLASH_WRITE_DATA_SIZE = SP_MAX_DATA_SIZE - sizeof(uint32_t);
 
 /**
  * The replay write sequence command has a maximum delay for the execution report which amounts to
@@ -131,7 +210,7 @@ static const uint16_t TC_EXEUTION_DISABLED = 0x5E2;
 static const uint16_t FLASH_MOUNT_FAILED = 0x5E3;
 static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4;
 static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5;
-static const uint16_t FLASH_FILE_ALREDY_OPEN = 0x5E6;
+static const uint16_t FLASH_FILE_ALREADY_OPEN = 0x5E6;
 static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7;
 static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8;
 static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9;
@@ -156,7 +235,7 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
   virtual ~TcBase() = default;
 
   // Initial length field of space packet. Will always be updated when packet is created.
-  static const uint16_t INIT_LENGTH = 2;
+  static const uint16_t INIT_LENGTH = CRC_SIZE;
 
   /**
    * @brief    Constructor
@@ -166,47 +245,23 @@ class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
    */
   TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
       : ploc::SpTcBase(params, apid, 0, sequenceCount) {
+    payloadStart = spParams.buf + ccsds::HEADER_LEN;
     spParams.setFullPayloadLen(INIT_LENGTH);
   }
 
-  ReturnValue_t buildPacket() { return buildPacket(nullptr, 0); }
-
   /**
-   * @brief   Function to initialize the space packet
-   *
-   * @param commandData       Pointer to command specific data
-   * @param commandDataLen    Length of command data
-   *
+   * @brief   Function to finsh and write the space packet. It is expected that the user has
+   * set the payload fields in the child class*
    * @return  returnvalue::OK if packet creation was successful, otherwise error return value
    */
-  ReturnValue_t buildPacket(const uint8_t* commandData, size_t commandDataLen) {
-    payloadStart = spParams.buf + ccsds::HEADER_LEN;
-    ReturnValue_t res;
-    if (commandData != nullptr and commandDataLen > 0) {
-      res = initPacket(commandData, commandDataLen);
-      if (res != returnvalue::OK) {
-        return res;
-      }
-    }
-
+  ReturnValue_t finishPacket() {
     updateSpFields();
-    res = checkSizeAndSerializeHeader();
+    ReturnValue_t res = checkSizeAndSerializeHeader();
     if (res != returnvalue::OK) {
       return res;
     }
     return calcAndSetCrc();
   }
-
- protected:
-  /**
-   * @brief   Must be overwritten by the child class to define the command specific parameters
-   *
-   * @param commandData       Pointer to received command data
-   * @param commandDataLen    Length of received command data
-   */
-  virtual ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    return returnvalue::OK;
-  }
 };
 
 /**
@@ -224,8 +279,7 @@ class TcMemRead : public TcBase {
 
   uint16_t getMemLen() const { return memLen; }
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = returnvalue::OK;
     result = lengthCheck(commandDataLen);
     if (result != returnvalue::OK) {
@@ -271,8 +325,7 @@ class TcMemWrite : public TcBase {
   TcMemWrite(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_MEM_WRITE, sequenceCount) {}
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = returnvalue::OK;
     result = lengthCheck(commandDataLen);
     if (result != returnvalue::OK) {
@@ -314,72 +367,58 @@ class TcMemWrite : public TcBase {
 /**
  * @brief   Class to help creation of flash fopen command.
  */
-class FlashFopen : public ploc::SpTcBase {
+class FlashFopen : public TcBase {
  public:
   FlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}
+      : TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}
 
-  static const char APPEND = 'a';
-  static const char WRITE = 'w';
-  static const char READ = 'r';
-
-  ReturnValue_t createPacket(std::string filename, char accessMode_) {
-    accessMode = accessMode_;
+  ReturnValue_t setPayload(std::string filename, uint8_t mode) {
+    accessMode = mode;
     size_t nameSize = filename.size();
-    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE);
+    spParams.setFullPayloadLen(256 + sizeof(uint8_t) + CRC_SIZE);
     ReturnValue_t result = checkPayloadLen();
     if (result != returnvalue::OK) {
       return result;
     }
     std::memcpy(payloadStart, filename.c_str(), nameSize);
-    *(spParams.buf + nameSize) = NULL_TERMINATOR;
-    std::memcpy(payloadStart + nameSize + sizeof(NULL_TERMINATOR), &accessMode, sizeof(accessMode));
-    updateSpFields();
-    return calcAndSetCrc();
+    // payloadStart[nameSize] = NULL_TERMINATOR;
+    std::memset(payloadStart + nameSize, 0, 256 - nameSize);
+    // payloadStart[255] = NULL_TERMINATOR;
+    payloadStart[256] = accessMode;
+    return returnvalue::OK;
   }
 
  private:
-  char accessMode = APPEND;
+  uint8_t accessMode = FileAccessModes::OPEN_EXISTING;
 };
 
 /**
  * @brief   Class to help creation of flash fclose command.
  */
-class FlashFclose : public ploc::SpTcBase {
+class FlashFclose : public TcBase {
  public:
   FlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) {}
-
-  ReturnValue_t createPacket(std::string filename) {
-    size_t nameSize = filename.size();
-    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
-    ReturnValue_t result = checkPayloadLen();
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    std::memcpy(payloadStart, filename.c_str(), nameSize);
-    *(payloadStart + nameSize) = NULL_TERMINATOR;
-    return calcAndSetCrc();
+      : TcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) {
+    spParams.setFullPayloadLen(CRC_SIZE);
   }
 };
 
 /**
  * @brief   Class to build flash write space packet.
  */
-class TcFlashWrite : public ploc::SpTcBase {
+class TcFlashWrite : public TcBase {
  public:
   TcFlashWrite(ploc::SpTcParams params, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid::TC_FLASHWRITE, sequenceCount) {}
+      : TcBase(params, apid::TC_FLASHWRITE, sequenceCount) {}
 
-  ReturnValue_t buildPacket(const uint8_t* writeData, uint32_t writeLen_) {
-    ReturnValue_t result = returnvalue::OK;
+  ReturnValue_t setPayload(const uint8_t* writeData, uint32_t writeLen_) {
     writeLen = writeLen_;
-    if (writeLen > MAX_DATA_SIZE) {
-      sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
+    if (writeLen > MAX_FLASH_WRITE_DATA_SIZE) {
+      sif::error << "TcFlashWrite: Command data too big" << std::endl;
       return returnvalue::FAILED;
     }
-    spParams.setFullPayloadLen(static_cast<uint16_t>(writeLen) + 4 + CRC_SIZE);
-    result = checkPayloadLen();
+    spParams.setFullPayloadLen(sizeof(uint32_t) + static_cast<uint16_t>(writeLen) + CRC_SIZE);
+    ReturnValue_t result = checkPayloadLen();
     if (result != returnvalue::OK) {
       return result;
     }
@@ -389,11 +428,11 @@ class TcFlashWrite : public ploc::SpTcBase {
     if (result != returnvalue::OK) {
       return result;
     }
-    std::memcpy(payloadStart + sizeof(writeLen), writeData, writeLen);
+    std::memcpy(payloadStart + sizeof(uint32_t), writeData, writeLen);
     updateSpFields();
-    auto res = checkSizeAndSerializeHeader();
-    if (res != returnvalue::OK) {
-      return res;
+    result = checkSizeAndSerializeHeader();
+    if (result != returnvalue::OK) {
+      return result;
     }
     return calcAndSetCrc();
   }
@@ -402,15 +441,52 @@ class TcFlashWrite : public ploc::SpTcBase {
   uint32_t writeLen = 0;
 };
 
+class TcFlashRead : public TcBase {
+ public:
+  TcFlashRead(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_FLASHREAD, sequenceCount) {}
+
+  ReturnValue_t setPayload(uint32_t readLen) {
+    if (readLen > MAX_FLASH_READ_DATA_SIZE) {
+      sif::error << "TcFlashRead: Read length " << readLen << " too large" << std::endl;
+      return returnvalue::FAILED;
+    }
+    spParams.setFullPayloadLen(sizeof(uint32_t) + CRC_SIZE);
+    ReturnValue_t result = checkPayloadLen();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    size_t serializedSize = ccsds::HEADER_LEN;
+    result = SerializeAdapter::serialize(&readLen, payloadStart, &serializedSize, spParams.maxSize,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    updateSpFields();
+    result = checkSizeAndSerializeHeader();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = calcAndSetCrc();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    readSize = readLen;
+    return result;
+  }
+
+  uint32_t readSize = 0;
+};
+
 /**
  * @brief   Class to help creation of flash delete command.
  */
-class TcFlashDelete : public ploc::SpTcBase {
+class TcFlashDelete : public TcBase {
  public:
   TcFlashDelete(ploc::SpTcParams params, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid::TC_FLASHDELETE, sequenceCount) {}
+      : TcBase(params, apid::TC_FLASHDELETE, sequenceCount) {}
 
-  ReturnValue_t buildPacket(std::string filename) {
+  ReturnValue_t setPayload(std::string filename) {
     size_t nameSize = filename.size();
     spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
     auto res = checkPayloadLen();
@@ -449,8 +525,7 @@ class TcReplayStart : public TcBase {
   TcReplayStart(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_REPLAY_START, sequenceCount) {}
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = returnvalue::OK;
     spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
     result = lengthCheck(commandDataLen);
@@ -498,8 +573,7 @@ class TcDownlinkPwrOn : public TcBase {
   TcDownlinkPwrOn(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = returnvalue::OK;
     result = lengthCheck(commandDataLen);
     if (result != returnvalue::OK) {
@@ -561,6 +635,30 @@ class TcDownlinkPwrOn : public TcBase {
   }
 };
 
+class TcGetHkReport : public TcBase {
+ public:
+  TcGetHkReport(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_HK_GET_REPORT, sequenceCount) {}
+};
+
+class TcGetDirContent : public TcBase {
+ public:
+  TcGetDirContent(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_FLASH_GET_DIRECTORY_CONTENT, sequenceCount) {}
+
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = returnvalue::OK;
+    // Yeah it needs to be 256.. even if the path is shorter.
+    spParams.setFullPayloadLen(256 + CRC_SIZE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    std::memcpy(payloadStart, commandData, commandDataLen);
+    payloadStart[255] = '\0';
+    return result;
+  }
+};
+
 /**
  * @brief   Class to build replay stop space packet.
  */
@@ -581,8 +679,7 @@ class TcReplayWriteSeq : public TcBase {
   TcReplayWriteSeq(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = returnvalue::OK;
     spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
     result = lengthCheck(commandDataLen);
@@ -611,36 +708,69 @@ class TcReplayWriteSeq : public TcBase {
 /**
  * @brief   Helps to extract the fields of the flash write command from the PUS packet.
  */
-class FlashWritePusCmd : public MPSoCReturnValuesIF {
+class FlashBasePusCmd : public MPSoCReturnValuesIF {
  public:
-  FlashWritePusCmd(){};
+  FlashBasePusCmd() = default;
+  virtual ~FlashBasePusCmd() = default;
 
-  ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
+  virtual ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
     if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
       return INVALID_LENGTH;
     }
-    obcFile = std::string(reinterpret_cast<const char*>(commandData));
-    if (obcFile.size() > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
+    size_t fileLen = strnlen(reinterpret_cast<const char*>(commandData), commandDataLen);
+    if (fileLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
       return FILENAME_TOO_LONG;
     }
-    mpsocFile = std::string(
-        reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR));
-    if (mpsocFile.size() > MAX_FILENAME_SIZE) {
+    obcFile = std::string(reinterpret_cast<const char*>(commandData), fileLen);
+    fileLen =
+        strnlen(reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
+                commandDataLen - obcFile.size() - 1);
+    if (fileLen > MAX_FILENAME_SIZE) {
       return MPSOC_FILENAME_TOO_LONG;
     }
+    mpsocFile = std::string(
+        reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
+        fileLen);
     return returnvalue::OK;
   }
 
-  std::string getObcFile() { return obcFile; }
+  const std::string& getObcFile() const { return obcFile; }
 
-  std::string getMPSoCFile() { return mpsocFile; }
+  const std::string& getMPSoCFile() const { return mpsocFile; }
+
+ protected:
+  size_t getParsedSize() const {
+    return getObcFile().size() + getMPSoCFile().size() + 2 * SIZE_NULL_TERMINATOR;
+  }
+  static const size_t SIZE_NULL_TERMINATOR = 1;
 
  private:
-  static const size_t SIZE_NULL_TERMINATOR = 1;
-  std::string obcFile = "";
-  std::string mpsocFile = "";
+  std::string obcFile;
+  std::string mpsocFile;
 };
 
+class FlashReadPusCmd : public FlashBasePusCmd {
+ public:
+  FlashReadPusCmd(){};
+
+  ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) override {
+    ReturnValue_t result = FlashBasePusCmd::extractFields(commandData, commandDataLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    if (commandDataLen < (getParsedSize() + 4)) {
+      return returnvalue::FAILED;
+    }
+    size_t deserDummy = 4;
+    return SerializeAdapter::deSerialize(&readSize, commandData + getParsedSize(), &deserDummy,
+                                         SerializeIF::Endianness::NETWORK);
+  }
+
+  size_t getReadSize() const { return readSize; }
+
+ private:
+  size_t readSize = 0;
+};
 /**
  * @brief   Class to build replay stop space packet.
  */
@@ -676,7 +806,7 @@ class TcCamTakePic : public TcBase {
   TcCamTakePic(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_CAM_TAKE_PIC, sequenceCount) {}
 
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     if (commandDataLen > MAX_DATA_LENGTH) {
       return INVALID_LENGTH;
     }
@@ -705,7 +835,7 @@ class TcSimplexSendFile : public TcBase {
   TcSimplexSendFile(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
 
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     if (commandDataLen > MAX_DATA_LENGTH) {
       return INVALID_LENGTH;
     }
@@ -730,7 +860,7 @@ class TcDownlinkDataModulate : public TcBase {
   TcDownlinkDataModulate(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_DOWNLINK_DATA_MODULATE, sequenceCount) {}
 
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     if (commandDataLen > MAX_DATA_LENGTH) {
       return INVALID_LENGTH;
     }
@@ -748,8 +878,7 @@ class TcCamcmdSend : public TcBase {
   TcCamcmdSend(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_CAM_CMD_SEND, sequenceCount) {}
 
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) override {
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
     if (commandDataLen > MAX_DATA_LENGTH) {
       return INVALID_LENGTH;
     }
@@ -774,6 +903,69 @@ class TcCamcmdSend : public TcBase {
   static const uint8_t CARRIAGE_RETURN = 0xD;
 };
 
+class HkReport : public StaticLocalDataSet<36> {
+ public:
+  HkReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HK_SET_ID) {}
+
+  HkReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HK_SET_ID)) {}
+
+  lp_var_t<uint32_t> status = lp_var_t<uint32_t>(sid.objectId, mpsoc::poolid::STATUS, this);
+  lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::MODE, this);
+  lp_var_t<uint8_t> downlinkPwrOn =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_PWR_ON, this);
+  lp_var_t<uint8_t> downlinkReplyActive =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, this);
+  lp_var_t<uint8_t> downlinkJesdSyncStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, this);
+  lp_var_t<uint8_t> downlinkDacStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_DAC_STATUS, this);
+  lp_var_t<uint8_t> camStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_STATUS, this);
+  lp_var_t<uint8_t> camSdiStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_SDI_STATUS, this);
+  lp_var_t<float> camFpgaTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_FPGA_TEMP, this);
+  lp_var_t<float> camSocTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_SOC_TEMP, this);
+  lp_var_t<float> sysmonTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_TEMP, this);
+  lp_var_t<float> sysmonVccInt = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCINT, this);
+  lp_var_t<float> sysmonVccAux = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCAUX, this);
+  lp_var_t<float> sysmonVccBram =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCBRAM, this);
+  lp_var_t<float> sysmonVccPaux =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPAUX, this);
+  lp_var_t<float> sysmonVccPint =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPINT, this);
+  lp_var_t<float> sysmonVccPdro =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPDRO, this);
+  lp_var_t<float> sysmonMb12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB12V, this);
+  lp_var_t<float> sysmonMb3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB3V3, this);
+  lp_var_t<float> sysmonMb1V8 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB1V8, this);
+  lp_var_t<float> sysmonVcc12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC12V, this);
+  lp_var_t<float> sysmonVcc5V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC5V, this);
+  lp_var_t<float> sysmonVcc3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3, this);
+  lp_var_t<float> sysmonVcc3V3VA =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3VA, this);
+  lp_var_t<float> sysmonVcc2V5DDR =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC2V5DDR, this);
+  lp_var_t<float> sysmonVcc1V2DDR =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC1V2DDR, this);
+  lp_var_t<float> sysmonVcc0V9 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V9, this);
+  lp_var_t<float> sysmonVcc0V6VTT =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V6VTT, this);
+  lp_var_t<float> sysmonSafeCotsCur =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_SAFE_COTS_CUR, this);
+  lp_var_t<float> sysmonNvm4XoCur =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_NVM4_XO_CUR, this);
+  lp_var_t<uint16_t> semUncorrectableErrs =
+      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, this);
+  lp_var_t<uint16_t> semCorrectableErrs =
+      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_CORRECTABLE_ERRS, this);
+  lp_var_t<uint8_t> semStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::SEM_STATUS, this);
+  lp_var_t<uint8_t> rebootMpsocRequired =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::REBOOT_MPSOC_REQUIRED, this);
+};
+
+uint16_t getStatusFromRawData(const uint8_t* data);
+std::string getStatusString(uint16_t status);
+
 }  // namespace mpsoc
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

mission/acs/GyrAdis1650XHandler.cpp

@@ -15,7 +15,7 @@ GyrAdis1650XHandler::GyrAdis1650XHandler(object_id_t objectId, object_id_t devic
 }
 
 void GyrAdis1650XHandler::doStartUp() {
-  if (internalState != InternalState::STARTUP) {
+  if (internalState == InternalState::NONE) {
     internalState = InternalState::STARTUP;
     commandExecuted = false;
   }
@@ -24,19 +24,21 @@ void GyrAdis1650XHandler::doStartUp() {
     if (not commandExecuted) {
       warningSwitch = true;
       breakCountdown.setTimeout(adis1650x::START_UP_TIME);
+      updatePeriodicReply(true, adis1650x::REPLY);
       commandExecuted = true;
     }
-    if (breakCountdown.hasTimedOut()) {
-      updatePeriodicReply(true, adis1650x::REPLY);
-      setMode(MODE_ON);
-      internalState = InternalState::NONE;
-    }
+  }
+  if (internalState == InternalState::STARTUP_DONE) {
+    setMode(MODE_ON);
+    commandExecuted = false;
+    internalState = InternalState::NONE;
   }
 }
 
 void GyrAdis1650XHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
     commandExecuted = false;
+    PoolReadGuard pg(&primaryDataset);
     primaryDataset.setValidity(false, true);
     internalState = InternalState::SHUTDOWN;
   }
@@ -56,7 +58,11 @@ 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;
+      adisRequest.cfg.decRateReg = adis1650x::DEC_RATE;
       return preparePeriodicRequest(acs::SimpleSensorMode::NORMAL);
     }
     case (InternalState::SHUTDOWN): {
@@ -87,6 +93,9 @@ ReturnValue_t GyrAdis1650XHandler::scanForReply(const uint8_t *start, size_t rem
       getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  if (internalState == InternalState::STARTUP) {
+    internalState = InternalState::STARTUP_DONE;
+  }
   *foundLen = remainingSize;
   if (remainingSize != sizeof(acs::Adis1650XReply)) {
     return returnvalue::FAILED;

mission/acs/GyrAdis1650XHandler.h

@@ -48,7 +48,7 @@ class GyrAdis1650XHandler : public DeviceHandlerBase {
 
   bool warningSwitch = true;
 
-  enum class InternalState { NONE, STARTUP, SHUTDOWN };
+  enum class InternalState { NONE, STARTUP, STARTUP_DONE, SHUTDOWN };
 
   InternalState internalState = InternalState::STARTUP;
   bool commandExecuted = false;

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;
   }

mission/acs/ImtqHandler.cpp

@@ -795,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,8 @@ void SusHandler::doStartUp() {
 
 void SusHandler::doShutDown() {
   if (internalState != InternalState::SHUTDOWN) {
+    PoolReadGuard pg(&dataset);
+    dataset.tempC = thermal::INVALID_TEMPERATURE;
     dataset.setValidity(false, true);
     internalState = InternalState::SHUTDOWN;
     commandExecuted = false;

mission/acs/acsBoardPolling.h

@@ -8,11 +8,6 @@
 
 namespace acs {
 
-struct Adis1650XRequest {
-  SimpleSensorMode mode;
-  adis1650x::Type type;
-};
-
 struct Adis1650XConfig {
   uint16_t diagStat;
   uint16_t filterSetting;
@@ -22,6 +17,12 @@ struct Adis1650XConfig {
   uint16_t prodId;
 };
 
+struct Adis1650XRequest {
+  SimpleSensorMode mode;
+  adis1650x::Type type;
+  Adis1650XConfig cfg;
+};
+
 struct Adis1650XData {
   double sensitivity = 0.0;
   // Angular velocities in all axes (X, Y and Z)

mission/acs/defs.h

@@ -3,41 +3,59 @@
 
 #include <eive/eventSubsystemIds.h>
 #include <fsfw/modes/HasModesIF.h>
+#include <mission/sysDefs.h>
 
 namespace acs {
 
 enum class SimpleSensorMode { NORMAL = 0, OFF = 1 };
 
-// These modes are the submodes of the ACS controller and the modes of the ACS subsystem.
+// These modes are the modes of the ACS controller and of the ACS subsystem.
 enum AcsMode : Mode_t {
   OFF = HasModesIF::MODE_OFF,
-  SAFE = 10,
-  PTG_IDLE = 11,
-  PTG_NADIR = 12,
-  PTG_TARGET = 13,
-  PTG_TARGET_GS = 14,
-  PTG_INERTIAL = 15,
+  SAFE = satsystem::Mode::SAFE,
+  PTG_IDLE = satsystem::Mode::PTG_IDLE,
+  PTG_NADIR = satsystem::Mode::PTG_NADIR,
+  PTG_TARGET = satsystem::Mode::PTG_TARGET,
+  PTG_TARGET_GS = satsystem::Mode::PTG_TARGET_GS,
+  PTG_INERTIAL = satsystem::Mode::PTG_INERTIAL,
 };
 
 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/gyroAdisHelpers.cpp

@@ -52,3 +52,14 @@ double adis1650x::rangMdlToSensitivity(uint16_t rangMdl) {
     }
   }
 }
+
+void adis1650x::prepareWriteRegCommand(uint8_t regStart, uint16_t val, uint8_t* outBuf,
+                                       size_t maxLen) {
+  if (maxLen < 4) {
+    return;
+  }
+  outBuf[0] = regStart | adis1650x::WRITE_MASK;
+  outBuf[1] = val & 0xff;
+  outBuf[2] = (regStart + 1) | adis1650x::WRITE_MASK;
+  outBuf[3] = (val >> 8) & 0xff;
+}

mission/acs/gyroAdisHelpers.h

@@ -16,6 +16,8 @@ enum class BurstModes {
 };
 
 size_t prepareReadCommand(const uint8_t* regList, size_t len, uint8_t* outBuf, size_t maxLen);
+void prepareWriteRegCommand(uint8_t regStart, uint16_t val, uint8_t* outBuf, size_t maxLen);
+
 BurstModes burstModeFromMscCtrl(uint16_t mscCtrl);
 double rangMdlToSensitivity(uint16_t rangMdl);
 
@@ -92,6 +94,9 @@ static constexpr size_t SENSOR_READOUT_SIZE = 20 + 2;
 static constexpr uint32_t ADIS_DATASET_ID = READ_SENSOR_DATA;
 static constexpr uint32_t ADIS_CFG_DATASET_ID = READ_OUT_CONFIG;
 
+static constexpr uint16_t FILT_CTRL = 0x0000;
+static constexpr uint16_t DEC_RATE = 0x00C7;
+
 enum GlobCmds : uint8_t {
   FACTORY_CALIBRATION = 0b0000'0010,
   SENSOR_SELF_TEST = 0b0000'0100,

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();
 };

mission/acs/str/ArcsecJsonParamBase.cpp

@@ -3,6 +3,10 @@
 
 #include "arcsecJsonKeys.h"
 
+extern "C" {
+#include <wire/common/genericstructs.h>
+}
+
 ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {}
 
 ReturnValue_t ArcsecJsonParamBase::create(uint8_t* buffer) {

mission/acs/str/ArcsecJsonParamBase.h

@@ -7,8 +7,6 @@
 #include <fstream>
 #include <nlohmann/json.hpp>
 
-#include "arcsec/common/generated/tmtcstructs.h"
-#include "arcsec/common/genericstructs.h"
 #include "eive/resultClassIds.h"
 #include "fsfw/returnvalues/returnvalue.h"
 

mission/acs/str/StarTrackerHandler.cpp

@@ -1,18 +1,24 @@
-#include <arcsec/client/generated/actionreq.h>
-#include <arcsec/client/generated/parameter.h>
-#include <arcsec/client/generated/telemetry.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/StarTrackerHandler.h>
 #include <mission/acs/str/strHelpers.h>
 #include <mission/acs/str/strJsonCommands.h>
 
+extern "C" {
+#include <sagitta/client/actionreq.h>
+#include <sagitta/client/client_tm_structs.h>
+#include <sagitta/client/parameter.h>
+#include <sagitta/client/telemetry.h>
+#include <wire/common/genericstructs.h>
+}
+
 #include <atomic>
 #include <fstream>
 #include <thread>
 
 #include "OBSWConfig.h"
-#include "arcsec/common/misc.h"
+#include "eive/definitions.h"
+#include "fsfw/thermal/tcsDefinitions.h"
 
 std::atomic_bool JCFG_DONE(false);
 
@@ -95,6 +101,22 @@ void StarTrackerHandler::doShutDown() {
   startupState = StartupState::IDLE;
   bootState = FwBootState::NONE;
   solutionSet.setReportingEnabled(false);
+  {
+    PoolReadGuard pg(&solutionSet);
+    solutionSet.caliQw.value = 0.0;
+    solutionSet.caliQx.value = 0.0;
+    solutionSet.caliQy.value = 0.0;
+    solutionSet.caliQz.value = 0.0;
+    solutionSet.isTrustWorthy.value = 0;
+    solutionSet.setValidity(false, true);
+  }
+  {
+    PoolReadGuard pg(&temperatureSet);
+    temperatureSet.fpgaTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.cmosTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.mcuTemperature = thermal::INVALID_TEMPERATURE;
+    temperatureSet.setValidity(false, true);
+  }
   reinitNextSetParam = false;
   setMode(_MODE_POWER_DOWN);
 }
@@ -148,7 +170,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       return EXECUTION_FINISHED;
     }
     case (startracker::SET_JSON_FILE_NAME): {
-      if (size > MAX_PATH_SIZE) {
+      if (size > config::MAX_PATH_SIZE) {
         return FILE_PATH_TOO_LONG;
       }
       paramJsonFile = std::string(reinterpret_cast<const char*>(data), size);
@@ -185,7 +207,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       if (result != returnvalue::OK) {
         return result;
       }
-      if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
+      if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
         return FILE_PATH_TOO_LONG;
       }
       result = strHelper->startImageUpload(std::string(reinterpret_cast<const char*>(data), size));
@@ -200,7 +222,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       if (result != returnvalue::OK) {
         return result;
       }
-      if (size > MAX_PATH_SIZE) {
+      if (size > config::MAX_PATH_SIZE) {
         return FILE_PATH_TOO_LONG;
       }
       result =
@@ -224,14 +246,14 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       return EXECUTION_FINISHED;
     }
     case (startracker::CHANGE_IMAGE_DOWNLOAD_FILE): {
-      if (size > MAX_FILE_NAME) {
+      if (size > config::MAX_FILENAME_SIZE) {
         return FILENAME_TOO_LONG;
       }
       strHelper->setDownloadImageName(std::string(reinterpret_cast<const char*>(data), size));
       return EXECUTION_FINISHED;
     }
     case (startracker::SET_FLASH_READ_FILENAME): {
-      if (size > MAX_FILE_NAME) {
+      if (size > config::MAX_FILENAME_SIZE) {
         return FILENAME_TOO_LONG;
       }
       strHelper->setFlashReadFilename(std::string(reinterpret_cast<const char*>(data), size));
@@ -242,7 +264,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       if (result != returnvalue::OK) {
         return result;
       }
-      if (size > MAX_PATH_SIZE + MAX_FILE_NAME) {
+      if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
         return FILE_PATH_TOO_LONG;
       }
       result =
@@ -277,7 +299,7 @@ void StarTrackerHandler::performOperationHook() {
   }
 }
 
-Submode_t StarTrackerHandler::getInitialSubmode() { return SUBMODE_BOOTLOADER; }
+Submode_t StarTrackerHandler::getInitialSubmode() { return startracker::SUBMODE_BOOTLOADER; }
 
 ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   if (strHelperHandlingSpecialRequest) {
@@ -705,7 +727,7 @@ ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t
         return INVALID_SUBMODE;
       }
     case MODE_ON:
-      if (submode == SUBMODE_BOOTLOADER || submode == SUBMODE_FIRMWARE) {
+      if (submode == startracker::SUBMODE_BOOTLOADER || submode == startracker::SUBMODE_FIRMWARE) {
         return returnvalue::OK;
       } else {
         return INVALID_SUBMODE;
@@ -736,6 +758,7 @@ void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 }
 
 void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
+  using namespace startracker;
   uint8_t dhbSubmode = getSubmode();
   // We hide that the transition to submode firmware actually goes through the submode bootloader.
   // This is because the startracker always starts in bootloader mode but we want to allow direct
@@ -762,6 +785,7 @@ void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
 }
 
 void StarTrackerHandler::doNormalTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+  using namespace startracker;
   if (subModeFrom == SUBMODE_FIRMWARE) {
     setMode(MODE_NORMAL);
   } else if (subModeFrom == SUBMODE_BOOTLOADER) {
@@ -787,7 +811,7 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) {
       if (toMode == MODE_NORMAL) {
         setMode(toMode, 0);
       } else {
-        setMode(toMode, SUBMODE_FIRMWARE);
+        setMode(toMode, startracker::SUBMODE_FIRMWARE);
       }
       sif::info << "STR: Firmware boot success" << std::endl;
       internalState = InternalState::IDLE;
@@ -878,7 +902,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
 
   switch (id) {
     case (startracker::REQ_TIME): {
-      result = handleTm(packet, timeSet, startracker::TimeSet::SIZE);
+      result = handleTm(packet, timeSet, startracker::TimeSet::SIZE, "REQ_TIME");
       break;
     }
     case (startracker::PING_REQUEST): {
@@ -893,7 +917,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     case (startracker::REQ_VERSION): {
-      result = handleTm(packet, versionSet, startracker::VersionSet::SIZE);
+      result = handleTm(packet, versionSet, startracker::VersionSet::SIZE, "REQ_VERSION");
       if (result != returnvalue::OK) {
         return result;
       }
@@ -904,23 +928,23 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     case (startracker::REQ_INTERFACE): {
-      result = handleTm(packet, interfaceSet, startracker::InterfaceSet::SIZE);
+      result = handleTm(packet, interfaceSet, startracker::InterfaceSet::SIZE, "REQ_INTERFACE");
       break;
     }
     case (startracker::REQ_POWER): {
-      result = handleTm(packet, powerSet, startracker::PowerSet::SIZE);
+      result = handleTm(packet, powerSet, startracker::PowerSet::SIZE, "REQ_POWER");
       break;
     }
     case (startracker::REQ_SOLUTION): {
-      result = handleTm(packet, solutionSet, startracker::SolutionSet::SIZE);
+      result = handleTm(packet, solutionSet, startracker::SolutionSet::SIZE, "REQ_SOLUTION");
       break;
     }
     case (startracker::REQ_TEMPERATURE): {
-      result = handleTm(packet, temperatureSet, startracker::TemperatureSet::SIZE);
+      result = handleTm(packet, temperatureSet, startracker::TemperatureSet::SIZE, "REQ_TEMP");
       break;
     }
     case (startracker::REQ_HISTOGRAM): {
-      result = handleTm(packet, histogramSet, startracker::HistogramSet::SIZE);
+      result = handleTm(packet, histogramSet, startracker::HistogramSet::SIZE, "REQ_HISTO");
       break;
     }
     case (startracker::SUBSCRIPTION):
@@ -1082,6 +1106,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
   localDataPoolMap.emplace(startracker::LISA_QZ, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(startracker::LISA_PERC_CLOSE, new PoolEntry<float>({0}));
   localDataPoolMap.emplace(startracker::LISA_NR_CLOSE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(startracker::STR_MODE, 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::SOLUTION_STRATEGY, new PoolEntry<uint8_t>({0}));
@@ -1561,7 +1586,7 @@ ReturnValue_t StarTrackerHandler::executeFlashReadCommand(const uint8_t* command
                << std::endl;
     return result;
   }
-  if (commandDataLen - sizeof(startRegion) - sizeof(length) > MAX_PATH_SIZE) {
+  if (commandDataLen - sizeof(startRegion) - sizeof(length) > config::MAX_PATH_SIZE) {
     sif::warning << "StarTrackerHandler::executeFlashReadCommand: Received command with invalid"
                  << " path and filename" << std::endl;
     return FILE_PATH_TOO_LONG;
@@ -1701,7 +1726,7 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
                                                       bool reinitSet) {
   // Stopwatch watch;
   ReturnValue_t result = returnvalue::OK;
-  if (commandDataLen > MAX_PATH_SIZE) {
+  if (commandDataLen > config::MAX_PATH_SIZE) {
     return FILE_PATH_TOO_LONG;
   }
   if (reinitSet) {
@@ -1969,7 +1994,7 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
 }
 
 ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
-                                           size_t size) {
+                                           size_t size, const char* context) {
   ReturnValue_t result = returnvalue::OK;
   uint8_t status = startracker::getStatusField(rawFrame);
   if (status != startracker::STATUS_OK) {
@@ -1985,7 +2010,8 @@ ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDat
   dataset.setValidityBufferGeneration(false);
   result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
   if (result != returnvalue::OK) {
-    sif::warning << "StarTrackerHandler::handleTm: Deserialization failed" << std::endl;
+    sif::warning << "StarTrackerHandler::handleTm: Deserialization failed for " << context
+                 << std::endl;
   }
   dataset.setValidityBufferGeneration(true);
   dataset.setValidity(true, true);

mission/acs/str/StarTrackerHandler.h

@@ -10,12 +10,15 @@
 #include <thread>
 
 #include "OBSWConfig.h"
-#include "arcsec/common/SLIP.h"
 #include "devices/powerSwitcherList.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/src/fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/timemanager/Countdown.h"
 
+extern "C" {
+#include <wire/common/SLIP.h>
+}
+
 /**
  * @brief	This is the device handler for the star tracker from arcsec.
  *
@@ -54,9 +57,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   Submode_t getInitialSubmode() override;
 
-  static const Submode_t SUBMODE_BOOTLOADER = 1;
-  static const Submode_t SUBMODE_FIRMWARE = 2;
-
  protected:
   void doStartUp() override;
   void doShutDown() override;
@@ -144,9 +144,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
   //! [EXPORT] : [COMMENT] Failed to boot star tracker into bootloader mode
   static const Event BOOTING_BOOTLOADER_FAILED_EVENT = MAKE_EVENT(2, severity::LOW);
 
-  static const size_t MAX_PATH_SIZE = 50;
-  static const size_t MAX_FILE_NAME = 30;
-
   static const uint8_t STATUS_OFFSET = 2;
   static const uint8_t PARAMS_OFFSET = 2;
   static const uint8_t TICKS_OFFSET = 3;
@@ -481,7 +478,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
    *
    * @return  returnvalue::OK if successful, otherwise error return value
    */
-  ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset, size_t size);
+  ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset, size_t size,
+                         const char* context);
 
   /**
    * @brief Checks if star tracker is in valid mode for executing the received command.