changelog, prep v5.2.0

Reviewed-on: #723

.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,367 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v6.0.0] to be released
+
+- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
+
+# [v5.2.0] 2023-07-02
+
+## Fixed
+
+- The firmware information event was not triggered even when possible because of an ordering
+  bug in the initializer function.
+- Empty dumps (no TM in time range) will now correctly be completed immediately
+
+## Changed
+
+- PTME was always reset on submode changes. The reset will now only be performed if the actual data
+  rate changes.
+- Add back ACS board code for the EM. Now that the radiation sensor was removed, the image switching
+  issue has disappeared and adding back the ACS board is worth it for the GPS timekeeping.
+
+# [v5.1.0] 2023-06-28
+
+- `eive-tmtc` version v5.1.0
+
+## Changed
+
+- Persistent TM store dumps are now performed in chronological order.
+- Increase Syrlinks RX HK rate to 5.0 seconds during a pass.
+- Various robustness improvements for the heater handler. The heater handler will now only
+  process the command queue if it is not busy with switch commanding which reduces the amount
+  of possible bugs.
+- The heater handler is only able to process messages stricly sequentially now but is scheduled
+  twice in a 0.5 second slot so something like a consecutive heater ON or OFF command can still
+  be handled relatively quickly.
+
+## Added
+
+- Sequence counters for PUS and CFDP packets are now stored persistently across graceful reboots.
+- The PUS packet message type counter will now be incremented properly for each PUS service.
+- Internal error reporter set is now enabled by default and generated every 120 seconds.
+
+# [v5.0.0] 2023-06-26
+
+v3.3.1 and all following version will now be moved to v5.0.0 with the additional changes listed
+here. This was done because the firmware update (v4.0.0) is not working right now and it is not
+known when and how it will be fixed. Because of that, all updates to make the SW work with the new
+firmware, which are limited to a few files will be moved to a dev branch so regular development
+compatible to the old firmware can continue.
+
+TLDR: This version is compatible to the old firmware and some changes which only work with the new
+firmware have been reverted.
+
+## Changed
+
+- Added `sync` syscall in graceful shutdown handler
+- Graceful shutdown is now performed by the reboot watchdog
+- There is now a separate file for the total reboot counter. The reboot watchdog has its own local
+  counters to determine whether a reboot is necessary.
+
+# [v4.0.1] 2023-06-24
+
+## Fixed
+
+- `PusLiveDemux` packet demultiplexing bugfix where the demultiplexing did not work when there was
+  only one destination available.
+
+# [v4.0.0] 2023-06-22
+
+- `eive-tmtc` version v5.0.0
+- `q7s-package` version v3.1.1
+
+## Fixed
+
+- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
+- TCS fixes: Set temperature values to invalid value for MAX31865 RTD handler, SUS handler
+  and STR handler. Also set dataset to invakid for RTD handler.
+- Fixed H parameter in SUS converter from 1 mm to 2.5 mm.
+
+## Changed
+
+- Removed PTME busy/ready signals. Those were not used anyway because register reads are used now.
+- APB bus access busy checking is not done anymore as this is performed by the bus itself now.
+- Core controller will now announce version and image information event in addition to reboot
+  event in the `inititalize` function.
+- Core controller will now try to request and announce the firmware version in addition to the
+  OBSW version as well.
+- Added core controller action to read reboot mechansm information
+- GNSS reset pin will now only be asserted for 5 ms instead of 100 ms.
+
+## Added
+
+- Added PL I2C reset pin. It is not used/connected for now but could be used for FDIR procedures to
+  restore the PL I2C.
+- Core controller now announces firmware version as well when requesting a version info event
+
+# [v3.3.1] 2023-06-22
+
+## Fixed
+
+- `PusLiveDemux` packet demultiplexing bugfix where the demultiplexing did not work when there was
+  only one destination available.
+
+## Fixed
+
+- Fixed H parameter in SUS converter from 1 mm to 2.5 mm.
+
+# [v3.3.0] 2023-06-21
+
+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
@@ -24,6 +385,7 @@ will consitute of a breaking change warranting a new major release:
 
 - 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
@@ -39,16 +401,22 @@ will consitute of a breaking change warranting a new major release:
   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.
-
-## Changed
-
 - 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

CMakeLists.txt

@@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 44)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_MAJOR 5)
+set(OBSW_VERSION_MINOR 2)
+set(OBSW_VERSION_REVISION 0)
 
 # 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,8 +101,11 @@ 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}
+    1
     CACHE STRING "Add ACS board module")
 set(OBSW_ADD_GPS_CTRL
     ${INIT_VAL}
@@ -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, enableHkSets);
 
+  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 285 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-07 17:42:57
+ * 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";
@@ -268,6 +276,8 @@ const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
+const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -275,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";
@@ -478,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;
@@ -604,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):
@@ -669,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):
@@ -819,6 +846,10 @@ const char *translateEvents(Event event) {
       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):
@@ -833,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-07 17:42:57
+ * 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,6 +84,7 @@ 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";
@@ -90,6 +93,7 @@ static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
 static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
 static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
 static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
+
 static constexpr char PTME_RESETN[] = "ptme_resetn";
 
 static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";

bsp_q7s/core/CoreController.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,18 +19,12 @@
 #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 {
+struct RebootWatchdogFile {
   static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
 
   bool enabled = true;
@@ -48,8 +45,97 @@ struct RebootFile {
   xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };
 
-class CoreController : public ExtendedControllerBase {
+class RebootWatchdogPacket : public SerialLinkedListAdapter<SerializeIF> {
  public:
+  RebootWatchdogPacket(RebootWatchdogFile& rf) {
+    enabled = rf.enabled;
+    maxCount = rf.maxCount;
+    img00Count = rf.img00Cnt;
+    img01Count = rf.img01Cnt;
+    img10Count = rf.img10Cnt;
+    img11Count = rf.img11Cnt;
+    img00Lock = rf.img00Lock;
+    img01Lock = rf.img01Lock;
+    img10Lock = rf.img10Lock;
+    img11Lock = rf.img11Lock;
+    lastChip = static_cast<uint8_t>(rf.lastChip);
+    lastCopy = static_cast<uint8_t>(rf.lastCopy);
+    nextChip = static_cast<uint8_t>(rf.mechanismNextChip);
+    nextCopy = static_cast<uint8_t>(rf.mechanismNextCopy);
+    setLinks();
+  }
+
+ private:
+  void setLinks() {
+    setStart(&enabled);
+    enabled.setNext(&maxCount);
+    maxCount.setNext(&img00Count);
+    img00Count.setNext(&img01Count);
+    img01Count.setNext(&img10Count);
+    img10Count.setNext(&img11Count);
+    img11Count.setNext(&img00Lock);
+    img00Lock.setNext(&img01Lock);
+    img01Lock.setNext(&img10Lock);
+    img10Lock.setNext(&img11Lock);
+    img11Lock.setNext(&lastChip);
+    lastChip.setNext(&lastCopy);
+    lastCopy.setNext(&nextChip);
+    nextChip.setNext(&nextCopy);
+    setLast(&nextCopy);
+  }
+
+  SerializeElement<uint8_t> enabled = false;
+  SerializeElement<uint32_t> maxCount = 0;
+  SerializeElement<uint32_t> img00Count = 0;
+  SerializeElement<uint32_t> img01Count = 0;
+  SerializeElement<uint32_t> img10Count = 0;
+  SerializeElement<uint32_t> img11Count = 0;
+  SerializeElement<uint8_t> img00Lock = false;
+  SerializeElement<uint8_t> img01Lock = false;
+  SerializeElement<uint8_t> img10Lock = false;
+  SerializeElement<uint8_t> img11Lock = false;
+  SerializeElement<uint8_t> lastChip = 0;
+  SerializeElement<uint8_t> lastCopy = 0;
+  SerializeElement<uint8_t> nextChip = 0;
+  SerializeElement<uint8_t> nextCopy = 0;
+};
+
+struct RebootCountersFile {
+  // 16 bit values so all boot counters fit into one event.
+  uint16_t img00Cnt = 0;
+  uint16_t img01Cnt = 0;
+  uint16_t img10Cnt = 0;
+  uint16_t img11Cnt = 0;
+};
+
+class RebootCountersPacket : public SerialLinkedListAdapter<SerializeIF> {
+  RebootCountersPacket(RebootCountersFile& rf) {
+    img00Count = rf.img00Cnt;
+    img01Count = rf.img01Cnt;
+    img10Count = rf.img10Cnt;
+    img11Count = rf.img11Cnt;
+    setLinks();
+  }
+
+ private:
+  void setLinks() {
+    setStart(&img00Count);
+    img00Count.setNext(&img01Count);
+    img01Count.setNext(&img10Count);
+    img10Count.setNext(&img11Count);
+    setLast(&img11Count);
+  }
+
+  SerializeElement<uint16_t> img00Count = 0;
+  SerializeElement<uint16_t> img01Count = 0;
+  SerializeElement<uint16_t> img10Count = 0;
+  SerializeElement<uint16_t> img11Count = 0;
+};
+
+class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
+ public:
+  enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
+
   static xsc::Chip CURRENT_CHIP;
   static xsc::Copy CURRENT_COPY;
 
@@ -57,23 +143,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);
-  const std::string REBOOT_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::VERSION_FILE_NAME);
+  const std::string LEGACY_REBOOT_WATCHDOG_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" +
+      std::string(core::LEGACY_REBOOT_WATCHDOG_FILE_NAME);
+  const std::string REBOOT_WATCHDOG_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_WATCHDOG_FILE_NAME);
   const std::string BACKUP_TIME_FILE =
-      "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_FILE_NAME);
+  const std::string REBOOT_COUNTERS_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_COUNTER_FILE_NAME);
 
   static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
   static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
   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;
@@ -149,9 +235,11 @@ 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 };
@@ -183,7 +271,22 @@ class CoreController : public ExtendedControllerBase {
     DeviceCommandId_t actionId;
   } sdCommandingInfo;
 
-  RebootFile rebootFile = {};
+  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{};
+
+  RebootWatchdogFile rebootWatchdogFile = {};
+  RebootCountersFile rebootCountersFile = {};
 
   CommandExecutor cmdExecutor;
   SimpleRingBuffer cmdReplyBuf;
@@ -216,10 +319,16 @@ class CoreController : public ExtendedControllerBase {
 
   core::HkSet hkSet;
 
+  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;
 
@@ -247,10 +356,18 @@ class CoreController : public ExtendedControllerBase {
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
   void executeNextExternalSdCommand();
   void checkExternalSdCommandStatus();
-  void performRebootFileHandling(bool recreateFile);
+  void performRebootWatchdogHandling(bool recreateFile);
+  void performRebootCountersHandling(bool recreateFile);
 
   ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
                                             const uint8_t* data, size_t size);
+  ReturnValue_t actionListDirectoryDumpDirectly(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                                const uint8_t* data, size_t size);
+  ReturnValue_t performGracefulShutdown(xsc::Chip targetChip, xsc::Copy targetCopy);
+
+  ReturnValue_t actionListDirectoryCommonCommandCreator(const uint8_t* data, size_t size,
+                                                        std::ostringstream& oss);
+
   ReturnValue_t actionXscReboot(const uint8_t* data, size_t size);
   ReturnValue_t actionReboot(const uint8_t* data, size_t size);
 
@@ -260,14 +377,19 @@ class CoreController : public ExtendedControllerBase {
   int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
                                 bool& protOperationPerformed, bool selfChip, bool selfCopy,
                                 bool allChips, bool allCopies, uint8_t arrIdx);
-  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
-                                 xsc::Copy& tgtCopy);
-  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  void rebootWatchdogAlgorithm(RebootWatchdogFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                               xsc::Copy& tgtCopy);
+  void resetRebootWatchdogCounters(xsc::Chip tgtChip, xsc::Copy tgtCopy);
   void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
-  bool parseRebootFile(std::string path, RebootFile& file);
-  void rewriteRebootFile(RebootFile file);
+  bool parseRebootWatchdogFile(std::string path, RebootWatchdogFile& file);
+  bool parseRebootCountersFile(std::string path, RebootCountersFile& file);
+  void rewriteRebootWatchdogFile(RebootWatchdogFile file);
+  void rewriteRebootCountersFile(RebootCountersFile file);
   void announceBootCounts();
+  void announceVersionInfo();
+  void announceCurrentImageInfo();
   void 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,
@@ -361,7 +355,7 @@ void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {
 
 void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
                                              SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher,
-                                             bool enableHkSets) {
+                                             bool enableHkSets, adis1650x::Type adisType) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
   createAcsBoardGpios(*gpioCookieAcsBoard);
@@ -447,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;
@@ -482,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;
@@ -514,7 +506,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
   debugGps = true;
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 100;
+  RESET_ARGS_GNSS.waitPeriodMs = 5;
   auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                 enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@@ -632,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);
@@ -653,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);
@@ -772,6 +765,7 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   VirtualChannelIF* vc3 =
       new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, 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);
@@ -813,7 +807,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);
 
@@ -1016,3 +1010,38 @@ 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 (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
+    if (gpioIF == nullptr) {
+      return;
+    }
+    GpioCookie* gpioI2cResetnCookie = new GpioCookie;
+    GpiodRegularByLineName* gpioI2cResetn = new GpiodRegularByLineName(
+        q7s::gpioNames::PL_I2C_ARESETN, "PL_I2C_ARESETN", Direction::OUT, Levels::HIGH);
+    gpioI2cResetnCookie->addGpio(gpioIds::PL_I2C_ARESETN, gpioI2cResetn);
+    gpioChecker(gpioIF->addGpios(gpioI2cResetnCookie), "PL I2C ARESETN");
+    // Reset I2C explicitely again.
+    gpioIF->pullLow(gpioIds::PL_I2C_ARESETN);
+    TaskFactory::delayTask(1);
+    gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
+  }
+}

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>
@@ -58,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, bool enableHkSets);
+                              PowerSwitchIF& pwrSwitcher, bool enableHkSets,
+                              adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                             HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
@@ -75,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

@@ -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,14 @@ 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
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
 
 #if OBSW_ADD_SYRLINKS == 1
   PeriodicTaskIF* syrlinksCom = factory->createPeriodicTask(
@@ -344,7 +349,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 +369,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 +475,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

@@ -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,
+                                       enableHkSets);
 
   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,34 +74,22 @@ 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, 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);
+  // Initialize chip select to avoid SPI bus issues.
+  createRadSensorChipSelect(gpioComIF);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
+                           adis1650x::Type::ADIS16507);
 #else
   // Still add all GPIOs for EM.
   GpioCookie* acsBoardGpios = new GpioCookie();
@@ -118,6 +117,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,
@@ -126,6 +127,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 */
@@ -135,7 +137,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,4 +1,5 @@
 #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>
@@ -32,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,
+                                       true);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -43,6 +45,7 @@ void ObjectFactory::produce(void* args) {
   /* Adding gpios for chip select decoding to the gpioComIf */
   q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
   gpioCallbacks::disableAllDecoder(gpioComIF);
+  createPlI2cResetGpio(gpioComIF);
 
   new CoreController(objects::CORE_CONTROLLER, enableHkSets);
   createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
@@ -58,7 +61,8 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
+                           adis1650x::Type::ADIS16505);
 #endif
   HeaterHandler* heaterHandler;
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
@@ -94,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 */

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,7 +95,6 @@ enum gpioId_t {
   EN_RW_CS,
 
   SPI_MUX,
-
   VC0_PAPB_EMPTY,
   VC0_PAPB_BUSY,
   VC1_PAPB_EMPTY,

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

@@ -11,6 +11,8 @@ static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
 static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
 static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
 static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
+static constexpr char PUS_SEQUENCE_COUNT_FILE[] = "pus-sequence-count.txt";
+static constexpr char CFDP_SEQUENCE_COUNT_FILE[] = "cfdp-sequence-count.txt";
 
 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
@@ -34,8 +36,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 +60,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/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() { setMode(MODE_ON); }
+void RwDummy::doStartUp() {
+  statusSet.setReportingEnabled(true);
+  setMode(MODE_ON);
+}
 
-void RwDummy::doShutDown() { setMode(MODE_OFF); }
+void RwDummy::doShutDown() {
+  statusSet.setReportingEnabled(false);
+  setMode(MODE_OFF);
+}
 
 ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
@@ -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

@@ -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,101 @@ 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_PLOC_CONSECUTIVE): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
+      }
+      if (cycles == 30) {
+        sif::debug << "Setting warmer PLOC temperature" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
+      }
+      if (cycles == 45) {
+        sif::debug << "Setting cold PLOC temperature again" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
+      }
+      if (cycles == 60) {
+        sif::debug << "Setting warmer PLOC temperature again" << std::endl;
+        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
+      }
+      break;
+    }
+    case (TestCase::COLD_CAMERA): {
+      if (cycles == 15) {
+        sif::debug << "Setting cold CAM temperature" << std::endl;
+        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,20 @@ 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,
+    COLD_PLOC_CONSECUTIVE = 7,
+  };
   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,14 +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);
   }
@@ -72,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);
@@ -194,9 +201,11 @@ 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));
@@ -212,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
@@ -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
@@ -260,8 +268,10 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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;MEDIUM;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
-14011;0x36bb;I2C_REBOOT;MEDIUM;I2C is unavailable. Recovery did not work, performing full reboot.;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
@@ -269,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

@@ -500,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
@@ -509,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
@@ -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
@@ -260,8 +268,10 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 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;MEDIUM;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
-14011;0x36bb;I2C_REBOOT;MEDIUM;I2C is unavailable. Recovery did not work, performing full reboot.;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
@@ -269,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

@@ -478,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
@@ -517,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
@@ -543,7 +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
-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 285 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-07 17:42:57
+ * 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";
@@ -268,6 +276,8 @@ const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
+const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -275,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";
@@ -478,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;
@@ -604,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):
@@ -669,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):
@@ -819,6 +846,10 @@ const char *translateEvents(Event event) {
       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):
@@ -833,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-07 17:42:57
+ * 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,8 @@
 #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,

linux/acs/AcsBoardPolling.cpp

@@ -113,6 +113,7 @@ 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.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) {
@@ -122,13 +123,14 @@ 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.replyResult = returnvalue::FAILED;
       adis.mode = req->mode;
     }
     return returnvalue::OK;
@@ -144,10 +146,11 @@ 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.replyResult = returnvalue::FAILED;
       gyro.mode = req->mode;
     }
     return returnvalue::OK;
@@ -162,11 +165,12 @@ 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.replyResult = returnvalue::FAILED;
       mgm.mode = req->mode;
     }
     return returnvalue::OK;
@@ -181,10 +185,11 @@ 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.replyResult = returnvalue::FAILED;
       mgm.mode = req->mode;
     }
     return returnvalue::OK;
@@ -372,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;
@@ -451,15 +530,20 @@ void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
   ReturnValue_t result;
   acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
   bool mustPerformStartup = false;
+  uint16_t decRate = 0;
   {
     MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
     mode = gyro.mode;
+    decRate = gyro.decRate;
     mustPerformStartup = gyro.performStartup;
   }
   if (mode == acs::SimpleSensorMode::OFF) {
     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;
@@ -487,13 +571,19 @@ 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;

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/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,11 +69,13 @@ 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].replyResult = returnvalue::FAILED;
     susDevs[susIdx].mode = susReq->mode;
   }
   if (state == InternalState::IDLE) {

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 285 translations.
+ * @brief    Auto-generated event translation file. Contains 296 translations.
  * @details
- * Generated on: 2023-04-07 17:42:57
+ * 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";
@@ -268,6 +276,8 @@ const char *REBOOT_COUNTER_STRING = "REBOOT_COUNTER";
 const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
+const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
+const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@@ -275,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";
@@ -478,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;
@@ -604,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):
@@ -669,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):
@@ -819,6 +846,10 @@ const char *translateEvents(Event event) {
       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):
@@ -833,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-07 17:42:57
+ * Generated on: 2023-06-21 19:01:02
  */
 #include "translateObjects.h"
 

linux/ipcore/AxiPtmeConfig.cpp

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

linux/ipcore/AxiPtmeConfig.h

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

linux/ipcore/PdecHandler.cpp

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

linux/ipcore/PdecHandler.h

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

linux/ipcore/PtmeConfig.cpp

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

linux/ipcore/PtmeConfig.h

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

linux/ipcore/pdec.h

@@ -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/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_ */

misc/eclipse/.cproject

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

mission/acs/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;
   }
@@ -60,6 +62,7 @@ ReturnValue_t GyrAdis1650XHandler::buildTransitionDeviceCommand(DeviceCommandId_
         return NOTHING_TO_SEND;
       }
       *id = adis1650x::REQUEST;
+      adisRequest.cfg.decRateReg = adis1650x::DEC_RATE;
       return preparePeriodicRequest(acs::SimpleSensorMode::NORMAL);
     }
     case (InternalState::SHUTDOWN): {
@@ -90,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/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/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/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 =
@@ -880,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): {
@@ -895,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;
       }
@@ -906,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):
@@ -1084,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}));
@@ -1563,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;
@@ -1703,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) {
@@ -1971,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) {
@@ -1987,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.
  *
@@ -141,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;
@@ -478,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.

mission/acs/str/arcsecJsonKeys.h

@@ -9,7 +9,7 @@ static const char PROPERTIES[] = "properties";
 static const char NAME[] = "name";
 static const char VALUE[] = "value";
 
-static const char LIMITS[] = "limits";
+static const char LIMITS[] = "Limits";
 static const char ACTION[] = "action";
 static const char FPGA18CURRENT[] = "FPGA18Current";
 static const char FPGA25CURRENT[] = "FPGA25Current";
@@ -22,20 +22,20 @@ static const char CMOSVRESCURRENT[] = "CMOSVResCurrent";
 static const char CMOS_TEMPERATURE[] = "CMOSTemperature";
 static const char MCU_TEMPERATURE[] = "MCUTemperature";
 
-static const char MOUNTING[] = "mounting";
+static const char MOUNTING[] = "Mounting";
 static const char qw[] = "qw";
 static const char qx[] = "qx";
 static const char qy[] = "qy";
 static const char qz[] = "qz";
 
-static const char IMAGE_PROCESSOR[] = "imageprocessor";
+static const char IMAGE_PROCESSOR[] = "ImageProcessor";
 static const char IMAGE_PROCESSOR_MODE[] = "mode";
 static const char STORE[] = "store";
 static const char SIGNAL_THRESHOLD[] = "signalThreshold";
 static const char IMAGE_PROCESSOR_DARK_THRESHOLD[] = "darkThreshold";
 static const char BACKGROUND_COMPENSATION[] = "backgroundcompensation";
 
-static const char CAMERA[] = "camera";
+static const char CAMERA[] = "Camera";
 static const char MODE[] = "mode";
 static const char FOCALLENGTH[] = "focallength";
 static const char EXPOSURE[] = "exposure";
@@ -77,7 +77,7 @@ static const char ENABLE_HISTOGRAM[] = "enableHistogram";
 static const char ENABLE_CONTRAST[] = "enableContrast";
 static const char BIN_MODE[] = "binMode";
 
-static const char CENTROIDING[] = "centroiding";
+static const char CENTROIDING[] = "Centroiding";
 static const char ENABLE_FILTER[] = "enableFilter";
 static const char MAX_QUALITY[] = "maxquality";
 static const char DARK_THRESHOLD[] = "darkthreshold";
@@ -92,7 +92,7 @@ static const char TRANSMATRIX_01[] = "transmatrix01";
 static const char TRANSMATRIX_10[] = "transmatrix10";
 static const char TRANSMATRIX_11[] = "transmatrix11";
 
-static const char LISA[] = "lisa";
+static const char LISA[] = "LISA";
 static const char LISA_MODE[] = "mode";
 static const char PREFILTER_DIST_THRESHOLD[] = "prefilterDistThreshold";
 static const char PREFILTER_ANGLE_THRESHOLD[] = "prefilterAngleThreshold";
@@ -108,29 +108,29 @@ static const char MAX_COMBINATIONS[] = "max_combinations";
 static const char NR_STARS_STOP[] = "nr_stars_stop";
 static const char FRACTION_CLOSE_STOP[] = "fraction_close_stop";
 
-static const char MATCHING[] = "matching";
+static const char MATCHING[] = "Matching";
 static const char SQUARED_DISTANCE_LIMIT[] = "squaredDistanceLimit";
 static const char SQUARED_SHIFT_LIMIT[] = "squaredShiftLimit";
 
-static const char VALIDATION[] = "validation";
+static const char VALIDATION[] = "Validation";
 static const char STABLE_COUNT[] = "stable_count";
 static const char MAX_DIFFERENCE[] = "max_difference";
 static const char MIN_TRACKER_CONFIDENCE[] = "min_trackerConfidence";
 static const char MIN_MATCHED_STARS[] = "min_matchedStars";
 
-static const char TRACKING[] = "tracking";
+static const char TRACKING[] = "Tracking";
 static const char THIN_LIMIT[] = "thinLimit";
 static const char OUTLIER_THRESHOLD[] = "outlierThreshold";
 static const char OUTLIER_THRESHOLD_QUEST[] = "outlierThresholdQUEST";
 static const char TRACKER_CHOICE[] = "trackerChoice";
 
-static const char ALGO[] = "algo";
+static const char ALGO[] = "Algo";
 static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence";
 static const char L2T_MIN_MATCHED[] = "l2t_minMatched";
 static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence";
 static const char T2L_MIN_MATCHED[] = "t2l_minMatched";
 
-static const char LOGLEVEL[] = "loglevel";
+static const char LOGLEVEL[] = "LogLevel";
 static const char LOGLEVEL1[] = "loglevel1";
 static const char LOGLEVEL2[] = "loglevel2";
 static const char LOGLEVEL3[] = "loglevel3";
@@ -148,7 +148,7 @@ static const char LOGLEVEL14[] = "loglevel14";
 static const char LOGLEVEL15[] = "loglevel15";
 static const char LOGLEVEL16[] = "loglevel16";
 
-static const char SUBSCRIPTION[] = "subscription";
+static const char SUBSCRIPTION[] = "Subscription";
 static const char TELEMETRY_1[] = "telemetry1";
 static const char TELEMETRY_2[] = "telemetry2";
 static const char TELEMETRY_3[] = "telemetry3";
@@ -166,13 +166,13 @@ static const char TELEMETRY_14[] = "telemetry14";
 static const char TELEMETRY_15[] = "telemetry15";
 static const char TELEMETRY_16[] = "telemetry16";
 
-static const char LOG_SUBSCRIPTION[] = "logsubscription";
+static const char LOG_SUBSCRIPTION[] = "LogSubscription";
 static const char LEVEL1[] = "level1";
 static const char MODULE1[] = "module1";
 static const char LEVEL2[] = "level2";
 static const char MODULE2[] = "module2";
 
-static const char DEBUG_CAMERA[] = "debugcamera";
+static const char DEBUG_CAMERA[] = "DebugCamera";
 static const char TIMING[] = "timing";
 static const char TEST[] = "test";
 

mission/acs/str/strHelpers.h

@@ -91,6 +91,7 @@ enum PoolIds : lp_id_t {
   LISA_QZ,
   LISA_PERC_CLOSE,
   LISA_NR_CLOSE,
+  STR_MODE,
   TRUST_WORTHY,
   STABLE_COUNT,
   SOLUTION_STRATEGY,
@@ -358,7 +359,7 @@ static const uint8_t VERSION_SET_ENTRIES = 5;
 static const uint8_t INTERFACE_SET_ENTRIES = 4;
 static const uint8_t POWER_SET_ENTRIES = 18;
 static const uint8_t TIME_SET_ENTRIES = 4;
-static const uint8_t SOLUTION_SET_ENTRIES = 23;
+static const uint8_t SOLUTION_SET_ENTRIES = 25;
 static const uint8_t HISTOGRAM_SET_ENTRIES = 38;
 static const uint8_t CHECKSUM_SET_ENTRIES = 1;
 static const uint8_t CAMERA_SET_ENTRIES = 24;
@@ -640,7 +641,7 @@ class TimeSet : public StaticLocalDataSet<TIME_SET_ENTRIES> {
  */
 class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 78;
+  static const size_t SIZE = 79;
 
   SolutionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SOLUTION_SET_ID) {}
 
@@ -682,6 +683,7 @@ class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
       lp_var_t<float>(sid.objectId, PoolIds::LISA_PERC_CLOSE, this);
   // Number of close stars in LISA solution
   lp_var_t<uint8_t> lisaNrClose = lp_var_t<uint8_t>(sid.objectId, PoolIds::LISA_NR_CLOSE, this);
+  lp_var_t<uint8_t> strMode = lp_var_t<uint8_t>(sid.objectId, PoolIds::STR_MODE, this);
   // Gives a combined overview of the validation parameters (1 for valid solution, otherwise 0)
   lp_var_t<uint8_t> isTrustWorthy = lp_var_t<uint8_t>(sid.objectId, PoolIds::TRUST_WORTHY, this);
   // Number of times the validation criteria was met

mission/cfdp/CMakeLists.txt

@@ -1,3 +1 @@
-
-target_sources(
-  ${LIB_EIVE_MISSION} PRIVATE CfdpHandler.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE CfdpHandler.cpp)

mission/cfdp/CfdpHandler.cpp

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

mission/com/CcsdsIpCoreHandler.cpp

@@ -246,7 +246,13 @@ ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submod
 void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) {
   triggerEvent(CHANGING_MODE, mode, submode);
   if (mode == HasModesIF::MODE_ON) {
-    if (this->submode != submode) {
+    uint32_t currentRate = ptmeConfig.getRate();
+    // Check whether the rate actually changes.
+    if ((this->submode != submode) and
+        (((submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW) and
+           (currentRate != RATE_100KBPS))) or
+         ((submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH) and
+           (currentRate != RATE_500KBPS))))) {
       initPtmeUpdateAfterXCycles();
       updateContext.enableTransmitAfterPtmeUpdate = true;
       updateContext.updateClockRate = true;

mission/com/SyrlinksHandler.cpp

@@ -773,11 +773,13 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   auto txStandbyHandler = [&]() {
     txDataset.setReportingEnabled(false);
     poolManager.changeCollectionInterval(temperatureSet.getSid(), 60.0);
+    poolManager.changeCollectionInterval(rxDataset.getSid(), 60.0);
     transState = TransitionState::SET_TX_STANDBY;
     internalState = InternalState::TX_TRANSITION;
   };
   auto txOnHandler = [&](TransitionState tgtTransitionState) {
     txDataset.setReportingEnabled(true);
+    poolManager.changeCollectionInterval(rxDataset.getSid(), 5.0);
     poolManager.changeCollectionInterval(txDataset.getSid(), 10.0);
     poolManager.changeCollectionInterval(temperatureSet.getSid(), 5.0);
     transState = tgtTransitionState;

mission/com/TmStoreTaskBase.cpp

@@ -45,13 +45,19 @@ bool TmStoreTaskBase::handleOneStore(PersistentTmStoreWithTmQueue& store,
   } else {
     Command_t execCmd;
     // Handle TC requests, for example deletion or retrieval requests.
+    // TODO: Not really clean here.. would be better if the executed command is returns as an
+    // enumeration.
     result = store.handleCommandQueue(ipcStore, execCmd);
-    if (result == returnvalue::OK) {
-      if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
+    if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
+      if (result == PersistentTmStore::DUMP_DONE) {
+        dumpDoneHandler(store, dumpContext);
+      } else if (result == returnvalue::OK) {
         cancelDumpCd.resetTimer();
         tmSinkBusyCd.resetTimer();
         dumpContext.reset();
       }
+    }
+    if (execCmd != CommandMessageIF::CMD_NONE) {
       tcRequestReceived = true;
     }
   }
@@ -94,13 +100,6 @@ void TmStoreTaskBase::cancelDump(DumpContext& ctx, PersistentTmStore& store, boo
 ReturnValue_t TmStoreTaskBase::handleOneDump(PersistentTmStoreWithTmQueue& store,
                                              DumpContext& dumpContext, bool& dumpPerformed) {
   ReturnValue_t result = returnvalue::OK;
-  // The PTME might have been reset an transmitter state change, so there is no point in continuing
-  // the dump.
-  // TODO: Will be solved in a cleaner way, this is kind of a hack.
-  if (not channel.isTxOn()) {
-    cancelDump(dumpContext, store, false);
-    return returnvalue::FAILED;
-  }
   // It is assumed that the PTME will only be locked for a short period (e.g. to change datarate).
   if (not channel.isBusy() and not ptmeLocked) {
     performDump(store, dumpContext, dumpPerformed);
@@ -126,37 +125,26 @@ ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
                                            DumpContext& dumpContext, bool& dumpPerformed) {
   size_t dumpedLen = 0;
 
-  auto dumpDoneHandler = [&]() {
-    uint32_t startTime;
-    uint32_t endTime;
-    store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
-    triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets,
-                 dumpContext.dumpedBytes);
-    dumpContext.reset();
-  };
   // Dump the next packet into the PTME.
   dumpContext.ptmeBusyCounter = 0;
   tmSinkBusyCd.resetTimer();
   ReturnValue_t result = store.getNextDumpPacket(tmReader, fileHasSwapped);
-  if (result != returnvalue::OK) {
-    sif::error << "PersistentTmStore: Getting next dump packet failed" << std::endl;
-  } else if (fileHasSwapped or result == PersistentTmStore::DUMP_DONE) {
+  if (fileHasSwapped and result == PersistentTmStore::DUMP_DONE) {
     // This can happen if a file is corrupted and the next file swap completes the dump.
-    dumpDoneHandler();
+    dumpDoneHandler(store, dumpContext);
     return returnvalue::OK;
+  } else if (result != returnvalue::OK) {
+    sif::error << "PersistentTmStore: Getting next dump packet failed" << std::endl;
+    return result;
   }
   dumpedLen = tmReader.getFullPacketLen();
-  // Only write to VC if mode is on, but always confirm the dump.
-  // If the mode is OFF, it is assumed the PTME is not usable and is not allowed to be written
-  // (e.g. to confirm a reset or the transmitter is off anyway).
-  if (mode == MODE_ON) {
-    result = channel.write(tmReader.getFullData(), dumpedLen);
-    if (result == DirectTmSinkIF::IS_BUSY) {
-      sif::warning << "PersistentTmStore: Unexpected VC channel busy" << std::endl;
-    } else if (result != returnvalue::OK) {
-      sif::warning << "PersistentTmStore: Unexpected VC channel write failure" << std::endl;
-    }
+  result = channel.write(tmReader.getFullData(), dumpedLen);
+  if (result == DirectTmSinkIF::IS_BUSY) {
+    sif::warning << "PersistentTmStore: Unexpected VC channel busy" << std::endl;
+  } else if (result != returnvalue::OK) {
+    sif::warning << "PersistentTmStore: Unexpected VC channel write failure" << std::endl;
   }
+
   result = store.confirmDump(tmReader, fileHasSwapped);
   if ((result == PersistentTmStore::DUMP_DONE or result == returnvalue::OK)) {
     dumpPerformed = true;
@@ -167,7 +155,7 @@ ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
     }
   }
   if (result == PersistentTmStore::DUMP_DONE) {
-    dumpDoneHandler();
+    dumpDoneHandler(store, dumpContext);
   }
   return returnvalue::OK;
 }
@@ -208,6 +196,14 @@ ReturnValue_t TmStoreTaskBase::connectModeTreeParent(HasModeTreeChildrenIF& pare
   return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
 }
 
+void TmStoreTaskBase::dumpDoneHandler(PersistentTmStore& store, DumpContext& dumpContext) {
+  uint32_t startTime;
+  uint32_t endTime;
+  store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
+  triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets, dumpContext.dumpedBytes);
+  dumpContext.reset();
+}
+
 ModeTreeChildIF& TmStoreTaskBase::getModeTreeChildIF() { return *this; }
 
 void TmStoreTaskBase::readCommandQueue(void) {

mission/com/TmStoreTaskBase.h

@@ -96,6 +96,8 @@ class TmStoreTaskBase : public SystemObject,
 
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override;
+  void dumpDoneHandler(PersistentTmStore& store, DumpContext& dumpContext);
+
   void announceMode(bool recursive) override;
   object_id_t getObjectId() const override;
   const HasHealthIF* getOptHealthIF() const override;

mission/com/VirtualChannel.cpp

@@ -11,23 +11,14 @@ ReturnValue_t VirtualChannel::sendNextTm(const uint8_t* data, size_t size) {
 }
 
 ReturnValue_t VirtualChannel::write(const uint8_t* data, size_t size) {
-  if (txOn) {
-    return ptme.writeToVc(vcId, data, size);
-  }
-  return returnvalue::OK;
+  return ptme.writeToVc(vcId, data, size);
 }
 
 uint8_t VirtualChannel::getVcid() const { return vcId; }
 
 const char* VirtualChannel::getName() const { return vcName.c_str(); }
 
-bool VirtualChannel::isBusy() const {
-  // Data is discarded, so channel is not busy.
-  if (not txOn) {
-    return false;
-  }
-  return ptme.isBusy(vcId);
-}
+bool VirtualChannel::isBusy() const { return ptme.isBusy(vcId); }
 
 void VirtualChannel::cancelTransfer() { ptme.cancelTransfer(vcId); }
 

mission/controller/AcsController.cpp

@@ -151,57 +151,70 @@ void AcsController::performSafe() {
   if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
       result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
     if (not mekfInvalidFlag) {
-      triggerEvent(acs::MEKF_INVALID_INFO);
+      triggerEvent(acs::MEKF_INVALID_INFO, (uint32_t)mekfData.mekfStatus.value);
       mekfInvalidFlag = true;
     }
     if (result == MultiplicativeKalmanFilter::MEKF_NOT_FINITE && !mekfLost) {
+      triggerEvent(acs::MEKF_AUTOMATIC_RESET);
       navigation.resetMekf(&mekfData);
       mekfLost = true;
     }
-  } else {
+  } else if (mekfInvalidFlag) {
+    triggerEvent(acs::MEKF_RECOVERY);
     mekfInvalidFlag = false;
   }
-  // get desired satellite rate and sun direction to align
-  double satRateSafe[3] = {0, 0, 0}, sunTargetDir[3] = {0, 0, 0};
-  guidance.getTargetParamsSafe(sunTargetDir, satRateSafe);
-  // if MEKF is working
+
+  // get desired satellite rate, sun direction to align to and inertia
+  double sunTargetDir[3] = {0, 0, 0};
+  guidance.getTargetParamsSafe(sunTargetDir);
+
   double magMomMtq[3] = {0, 0, 0}, errAng = 0.0;
-  if (result == MultiplicativeKalmanFilter::MEKF_RUNNING) {
-    result = safeCtrl.safeMekf(now, mekfData.quatMekf.value, mekfData.quatMekf.isValid(),
-                               mgmDataProcessed.magIgrfModel.value,
-                               mgmDataProcessed.magIgrfModel.isValid(),
-                               susDataProcessed.sunIjkModel.value, susDataProcessed.isValid(),
-                               mekfData.satRotRateMekf.value, mekfData.satRotRateMekf.isValid(),
-                               sunTargetDir, satRateSafe, &errAng, magMomMtq);
-  } else {
-    result = safeCtrl.safeNoMekf(
-        now, susDataProcessed.susVecTot.value, susDataProcessed.susVecTot.isValid(),
-        susDataProcessed.susVecTotDerivative.value, susDataProcessed.susVecTotDerivative.isValid(),
-        mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
-        mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTotDerivative.isValid(),
-        sunTargetDir, satRateSafe, &errAng, magMomMtq);
-  }
-  if (result == returnvalue::FAILED) {
-    if (not safeCtrlFailureFlag) {
-      triggerEvent(acs::SAFE_MODE_CONTROLLER_FAILURE);
-      safeCtrlFailureFlag = true;
-    }
-    safeCtrlFailureCounter++;
-    if (safeCtrlFailureCounter > 150) {
+  acs::SafeModeStrategy safeCtrlStrat = safeCtrl.safeCtrlStrategy(
+      mgmDataProcessed.mgmVecTot.isValid(), not mekfInvalidFlag,
+      gyrDataProcessed.gyrVecTot.isValid(), susDataProcessed.susVecTot.isValid(),
+      acsParameters.safeModeControllerParameters.useMekf,
+      acsParameters.safeModeControllerParameters.dampingDuringEclipse);
+  switch (safeCtrlStrat) {
+    case (acs::SafeModeStrategy::SAFECTRL_ACTIVE_MEKF):
+      safeCtrl.safeMekf(mgmDataProcessed.mgmVecTot.value, mekfData.satRotRateMekf.value,
+                        susDataProcessed.sunIjkModel.value, mekfData.quatMekf.value, sunTargetDir,
+                        magMomMtq, errAng);
       safeCtrlFailureFlag = false;
       safeCtrlFailureCounter = 0;
-    }
-  } else {
-    safeCtrlFailureFlag = false;
-    safeCtrlFailureCounter = 0;
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_WITHOUT_MEKF):
+      safeCtrl.safeNonMekf(mgmDataProcessed.mgmVecTot.value, gyrDataProcessed.gyrVecTot.value,
+                           susDataProcessed.susVecTot.value, sunTargetDir, magMomMtq, errAng);
+      safeCtrlFailureFlag = false;
+      safeCtrlFailureCounter = 0;
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING):
+      safeCtrl.safeRateDamping(mgmDataProcessed.mgmVecTot.value, gyrDataProcessed.gyrVecTot.value,
+                               sunTargetDir, magMomMtq, errAng);
+      safeCtrlFailureFlag = false;
+      safeCtrlFailureCounter = 0;
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_ECLIPSE_IDELING):
+      errAng = NAN;
+      safeCtrlFailureFlag = false;
+      safeCtrlFailureCounter = 0;
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_NO_MAG_FIELD_FOR_CONTROL):
+      safeCtrlFailure(1, 0);
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL):
+      safeCtrlFailure(0, 1);
+      break;
+    default:
+      sif::error << "AcsController: Invalid safe mode strategy for performSafe" << std::endl;
+      break;
   }
 
-  actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs,
-                          *acsParameters.magnetorquerParameter.inverseAlignment,
-                          acsParameters.magnetorquerParameter.dipolMax);
+  actuatorCmd.cmdDipoleMtq(*acsParameters.magnetorquerParameter.inverseAlignment,
+                           acsParameters.magnetorquerParameter.dipoleMax, magMomMtq, cmdDipoleMtqs);
 
   // detumble check and switch
-  if (mekfData.satRotRateMekf.isValid() &&
+  if (mekfData.satRotRateMekf.isValid() && acsParameters.safeModeControllerParameters.useMekf &&
       VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) >
           acsParameters.detumbleParameter.omegaDetumbleStart) {
     detumbleCounter++;
@@ -219,10 +232,10 @@ void AcsController::performSafe() {
     startTransition(mode, acs::SafeSubmode::DETUMBLE);
   }
 
-  updateCtrlValData(errAng);
-  updateActuatorCmdData(cmdDipolMtqs);
-  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
-  //                   acsParameters.magnetorquerParameter.torqueDuration);
+  updateCtrlValData(errAng, safeCtrlStrat);
+  updateActuatorCmdData(cmdDipoleMtqs);
+  commandActuators(cmdDipoleMtqs[0], cmdDipoleMtqs[1], cmdDipoleMtqs[2],
+                   acsParameters.magnetorquerParameter.torqueDuration);
 }
 
 void AcsController::performDetumble() {
@@ -236,23 +249,45 @@ void AcsController::performDetumble() {
   if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
       result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
     if (not mekfInvalidFlag) {
-      triggerEvent(acs::MEKF_INVALID_INFO);
+      triggerEvent(acs::MEKF_INVALID_INFO, (uint32_t)mekfData.mekfStatus.value);
       mekfInvalidFlag = true;
     }
     if (result == MultiplicativeKalmanFilter::MEKF_NOT_FINITE && !mekfLost) {
+      triggerEvent(acs::MEKF_AUTOMATIC_RESET);
       navigation.resetMekf(&mekfData);
+      mekfLost = true;
     }
-  } else {
+  } else if (mekfInvalidFlag) {
+    triggerEvent(acs::MEKF_RECOVERY);
     mekfInvalidFlag = false;
   }
+  acs::SafeModeStrategy safeCtrlStrat = detumble.detumbleStrategy(
+      mgmDataProcessed.mgmVecTot.isValid(), gyrDataProcessed.gyrVecTot.isValid(),
+      mgmDataProcessed.mgmVecTotDerivative.isValid(),
+      acsParameters.detumbleParameter.useFullDetumbleLaw);
   double magMomMtq[3] = {0, 0, 0};
-  detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value,
-                   mgmDataProcessed.mgmVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
-                   mgmDataProcessed.mgmVecTot.isValid(), magMomMtq,
-                   acsParameters.detumbleParameter.gainD);
-  actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs,
-                          *acsParameters.magnetorquerParameter.inverseAlignment,
-                          acsParameters.magnetorquerParameter.dipolMax);
+  switch (safeCtrlStrat) {
+    case (acs::SafeModeStrategy::SAFECTRL_DETUMBLE_FULL):
+      detumble.bDotLawFull(gyrDataProcessed.gyrVecTot.value, mgmDataProcessed.mgmVecTot.value,
+                           magMomMtq, acsParameters.detumbleParameter.gainFull);
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_DETUMBLE_DETERIORATED):
+      detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value, mgmDataProcessed.mgmVecTot.value,
+                       magMomMtq, acsParameters.detumbleParameter.gainBdot);
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_NO_MAG_FIELD_FOR_CONTROL):
+      safeCtrlFailure(1, 0);
+      break;
+    case (acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL):
+      safeCtrlFailure(0, 1);
+      break;
+    default:
+      sif::error << "AcsController: Invalid safe mode strategy for performDetumble" << std::endl;
+      break;
+  }
+
+  actuatorCmd.cmdDipoleMtq(*acsParameters.magnetorquerParameter.inverseAlignment,
+                           acsParameters.magnetorquerParameter.dipoleMax, magMomMtq, cmdDipoleMtqs);
 
   if (mekfData.satRotRateMekf.isValid() &&
       VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) <
@@ -273,10 +308,9 @@ void AcsController::performDetumble() {
   }
 
   disableCtrlValData();
-  updateActuatorCmdData(cmdDipolMtqs);
-  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
-  //                   acsParameters.magnetorquesParameter.torqueDuration, 0, 0, 0, 0,
-  //                   acsParameters.rwHandlingParameters.rampTime);
+  updateActuatorCmdData(cmdDipoleMtqs);
+  commandActuators(cmdDipoleMtqs[0], cmdDipoleMtqs[1], cmdDipoleMtqs[2],
+                   acsParameters.magnetorquerParameter.torqueDuration);
 }
 
 void AcsController::performPointingCtrl() {
@@ -291,21 +325,22 @@ void AcsController::performPointingCtrl() {
       result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
     mekfInvalidCounter++;
     if (not mekfInvalidFlag) {
-      triggerEvent(acs::MEKF_INVALID_INFO);
+      triggerEvent(acs::MEKF_INVALID_INFO, (uint32_t)mekfData.mekfStatus.value);
       mekfInvalidFlag = true;
     }
     if (result == MultiplicativeKalmanFilter::MEKF_NOT_FINITE && !mekfLost) {
+      triggerEvent(acs::MEKF_AUTOMATIC_RESET);
       navigation.resetMekf(&mekfData);
+      mekfLost = true;
     }
     if (mekfInvalidCounter > acsParameters.onBoardParams.mekfViolationTimer) {
       // Trigger this so STR FDIR can set the device faulty.
       EventManagerIF::triggerEvent(objects::STAR_TRACKER, acs::MEKF_INVALID_MODE_VIOLATION, 0, 0);
       mekfInvalidCounter = 0;
     }
-    //    commandActuators(0, 0, 0, acsParameters.magnetorquesParameter.torqueDuration,
-    //    cmdSpeedRws[0],
-    //                     cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
-    //                     acsParameters.rwHandlingParameters.rampTime);
+    commandActuators(0, 0, 0, acsParameters.magnetorquerParameter.torqueDuration, cmdSpeedRws[0],
+                     cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
+                     acsParameters.rwHandlingParameters.rampTime);
     return;
   } else {
     if (mekfInvalidFlag) {
@@ -318,8 +353,10 @@ void AcsController::performPointingCtrl() {
   double rwPseudoInv[4][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
   result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
   if (result == returnvalue::FAILED) {
-    if (multipleRwUnavailableCounter == 5) {
+    if (multipleRwUnavailableCounter >=
+        acsParameters.rwHandlingParameters.multipleRwInvalidTimeout) {
       triggerEvent(acs::MULTIPLE_RW_INVALID);
+      multipleRwUnavailableCounter = 0;
     }
     multipleRwUnavailableCounter++;
     return;
@@ -333,24 +370,26 @@ void AcsController::performPointingCtrl() {
   // Variables required for setting actuators
   double torquePtgRws[4] = {0, 0, 0, 0}, rwTrqNs[4] = {0, 0, 0, 0}, torqueRws[4] = {0, 0, 0, 0},
          mgtDpDes[3] = {0, 0, 0};
+
   switch (mode) {
     case acs::PTG_IDLE:
-      guidance.targetQuatPtgSun(susDataProcessed.sunIjkModel.value, targetQuat, targetSatRotRate);
+      guidance.targetQuatPtgSun(now, susDataProcessed.sunIjkModel.value, targetQuat,
+                                targetSatRotRate);
       guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
                           targetSatRotRate, errorQuat, errorSatRotRate, errorAngle);
       ptgCtrl.ptgLaw(&acsParameters.idleModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
-      ptgCtrl.ptgNullspace(
-          &acsParameters.idleModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
-          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
-          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      ptgCtrl.ptgNullspace(&acsParameters.idleModeControllerParameters,
+                           sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                           sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+                           rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
           &acsParameters.idleModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
-          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       enableAntiStiction = acsParameters.idleModeControllerParameters.enableAntiStiction;
       break;
 
@@ -364,17 +403,17 @@ void AcsController::performPointingCtrl() {
                           errorSatRotRate, errorAngle);
       ptgCtrl.ptgLaw(&acsParameters.targetModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
-      ptgCtrl.ptgNullspace(
-          &acsParameters.targetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
-          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
-          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      ptgCtrl.ptgNullspace(&acsParameters.targetModeControllerParameters,
+                           sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                           sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+                           rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
           &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
-          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       enableAntiStiction = acsParameters.targetModeControllerParameters.enableAntiStiction;
       break;
 
@@ -385,17 +424,17 @@ void AcsController::performPointingCtrl() {
                           targetSatRotRate, errorQuat, errorSatRotRate, errorAngle);
       ptgCtrl.ptgLaw(&acsParameters.gsTargetModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
-      ptgCtrl.ptgNullspace(
-          &acsParameters.gsTargetModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
-          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
-          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      ptgCtrl.ptgNullspace(&acsParameters.gsTargetModeControllerParameters,
+                           sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                           sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+                           rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
           &acsParameters.gsTargetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
-          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       enableAntiStiction = acsParameters.gsTargetModeControllerParameters.enableAntiStiction;
       break;
 
@@ -409,66 +448,76 @@ void AcsController::performPointingCtrl() {
                           errorSatRotRate, errorAngle);
       ptgCtrl.ptgLaw(&acsParameters.nadirModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
-      ptgCtrl.ptgNullspace(
-          &acsParameters.nadirModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
-          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
-          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      ptgCtrl.ptgNullspace(&acsParameters.nadirModeControllerParameters,
+                           sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                           sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+                           rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
           &acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
-          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       enableAntiStiction = acsParameters.nadirModeControllerParameters.enableAntiStiction;
       break;
 
     case acs::PTG_INERTIAL:
       std::memcpy(targetQuat, acsParameters.inertialModeControllerParameters.tgtQuat,
-                  4 * sizeof(double));
+                  sizeof(targetQuat));
       guidance.comparePtg(mekfData.quatMekf.value, mekfData.satRotRateMekf.value, targetQuat,
                           targetSatRotRate, acsParameters.inertialModeControllerParameters.quatRef,
                           acsParameters.inertialModeControllerParameters.refRotRate, errorQuat,
                           errorSatRotRate, errorAngle);
       ptgCtrl.ptgLaw(&acsParameters.inertialModeControllerParameters, errorQuat, errorSatRotRate,
                      *rwPseudoInv, torquePtgRws);
-      ptgCtrl.ptgNullspace(
-          &acsParameters.inertialModeControllerParameters, &(sensorValues.rw1Set.currSpeed.value),
-          &(sensorValues.rw2Set.currSpeed.value), &(sensorValues.rw3Set.currSpeed.value),
-          &(sensorValues.rw4Set.currSpeed.value), rwTrqNs);
+      ptgCtrl.ptgNullspace(&acsParameters.inertialModeControllerParameters,
+                           sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                           sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+                           rwTrqNs);
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
           &acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
           mgmDataProcessed.mgmVecTot.isValid(), mekfData.satRotRateMekf.value,
-          &(sensorValues.rw1Set.currSpeed.value), &(sensorValues.rw2Set.currSpeed.value),
-          &(sensorValues.rw3Set.currSpeed.value), &(sensorValues.rw4Set.currSpeed.value), mgtDpDes);
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       enableAntiStiction = acsParameters.inertialModeControllerParameters.enableAntiStiction;
       break;
     default:
-      sif::error << "AcsController: Invalid mode for performPointingCtrl";
+      sif::error << "AcsController: Invalid mode for performPointingCtrl" << std::endl;
       break;
   }
 
   actuatorCmd.cmdSpeedToRws(
       sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
-      sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, torqueRws,
-      cmdSpeedRws, acsParameters.onBoardParams.sampleTime,
-      acsParameters.rwHandlingParameters.maxRwSpeed,
-      acsParameters.rwHandlingParameters.inertiaWheel);
+      sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value,
+      acsParameters.onBoardParams.sampleTime, acsParameters.rwHandlingParameters.inertiaWheel,
+      acsParameters.rwHandlingParameters.maxRwSpeed, torqueRws, cmdSpeedRws);
   if (enableAntiStiction) {
     ptgCtrl.rwAntistiction(&sensorValues, cmdSpeedRws);
   }
-  actuatorCmd.cmdDipolMtq(mgtDpDes, cmdDipolMtqs,
-                          *acsParameters.magnetorquerParameter.inverseAlignment,
-                          acsParameters.magnetorquerParameter.dipolMax);
+  actuatorCmd.cmdDipoleMtq(*acsParameters.magnetorquerParameter.inverseAlignment,
+                           acsParameters.magnetorquerParameter.dipoleMax, mgtDpDes, cmdDipoleMtqs);
 
   updateCtrlValData(targetQuat, errorQuat, errorAngle, targetSatRotRate);
-  updateActuatorCmdData(torqueRws, cmdSpeedRws, cmdDipolMtqs);
-  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
-  //                   acsParameters.magnetorquesParameter.torqueDuration, cmdSpeedRws[0],
-  //                   cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
-  //                   acsParameters.rwHandlingParameters.rampTime);
+  updateActuatorCmdData(torqueRws, cmdSpeedRws, cmdDipoleMtqs);
+  commandActuators(cmdDipoleMtqs[0], cmdDipoleMtqs[1], cmdDipoleMtqs[2],
+                   acsParameters.magnetorquerParameter.torqueDuration, cmdSpeedRws[0],
+                   cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
+                   acsParameters.rwHandlingParameters.rampTime);
+}
+
+void AcsController::safeCtrlFailure(uint8_t mgmFailure, uint8_t sensorFailure) {
+  if (not safeCtrlFailureFlag) {
+    triggerEvent(acs::SAFE_MODE_CONTROLLER_FAILURE, mgmFailure, sensorFailure);
+    safeCtrlFailureFlag = true;
+  }
+  safeCtrlFailureCounter++;
+  if (safeCtrlFailureCounter > 150) {
+    safeCtrlFailureFlag = false;
+    safeCtrlFailureCounter = 0;
+  }
 }
 
 ReturnValue_t AcsController::commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
@@ -529,17 +578,19 @@ void AcsController::updateActuatorCmdData(const double *rwTargetTorque,
   }
 }
 
-void AcsController::updateCtrlValData(double errAng) {
+void AcsController::updateCtrlValData(double errAng, uint8_t safeModeStrat) {
   PoolReadGuard pg(&ctrlValData);
   if (pg.getReadResult() == returnvalue::OK) {
-    std::memcpy(ctrlValData.tgtQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    std::memcpy(ctrlValData.tgtQuat.value, ZERO_VEC4, 4 * sizeof(double));
     ctrlValData.tgtQuat.setValid(false);
-    std::memcpy(ctrlValData.errQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    std::memcpy(ctrlValData.errQuat.value, ZERO_VEC4, 4 * sizeof(double));
     ctrlValData.errQuat.setValid(false);
     ctrlValData.errAng.value = errAng;
     ctrlValData.errAng.setValid(true);
-    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC, 3 * sizeof(double));
+    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC3, 3 * sizeof(double));
     ctrlValData.tgtRotRate.setValid(false);
+    ctrlValData.safeStrat.value = safeModeStrat;
+    ctrlValData.safeStrat.setValid(true);
     ctrlValData.setValidity(true, false);
   }
 }
@@ -552,6 +603,7 @@ void AcsController::updateCtrlValData(const double *tgtQuat, const double *errQu
     std::memcpy(ctrlValData.errQuat.value, errQuat, 4 * sizeof(double));
     ctrlValData.errAng.value = errAng;
     std::memcpy(ctrlValData.tgtRotRate.value, tgtRotRate, 3 * sizeof(double));
+    ctrlValData.safeStrat.value = acs::SafeModeStrategy::SAFECTRL_OFF;
     ctrlValData.setValidity(true, true);
   }
 }
@@ -559,10 +611,10 @@ void AcsController::updateCtrlValData(const double *tgtQuat, const double *errQu
 void AcsController::disableCtrlValData() {
   PoolReadGuard pg(&ctrlValData);
   if (pg.getReadResult() == returnvalue::OK) {
-    std::memcpy(ctrlValData.tgtQuat.value, UNIT_QUAT, 4 * sizeof(double));
-    std::memcpy(ctrlValData.errQuat.value, UNIT_QUAT, 4 * sizeof(double));
+    std::memcpy(ctrlValData.tgtQuat.value, ZERO_VEC4, 4 * sizeof(double));
+    std::memcpy(ctrlValData.errQuat.value, ZERO_VEC4, 4 * sizeof(double));
     ctrlValData.errAng.value = 0;
-    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC, 3 * sizeof(double));
+    std::memcpy(ctrlValData.tgtRotRate.value, ZERO_VEC3, 3 * sizeof(double));
     ctrlValData.setValidity(false, true);
   }
 }
@@ -644,6 +696,7 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
   localDataPoolMap.emplace(acsctrl::PoolIds::MEKF_STATUS, &mekfStatus);
   poolManager.subscribeForDiagPeriodicPacket({mekfData.getSid(), enableHkSets, 10.0});
   // Ctrl Values
+  localDataPoolMap.emplace(acsctrl::PoolIds::SAFE_STRAT, &safeStrat);
   localDataPoolMap.emplace(acsctrl::PoolIds::TGT_QUAT, &tgtQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_QUAT, &errQuat);
   localDataPoolMap.emplace(acsctrl::PoolIds::ERROR_ANG, &errAng);

mission/controller/AcsController.h

@@ -12,18 +12,17 @@
 #include <mission/acs/imtqHelpers.h>
 #include <mission/acs/rwHelpers.h>
 #include <mission/acs/susMax1227Helpers.h>
+#include <mission/controller/acs/ActuatorCmd.h>
+#include <mission/controller/acs/Guidance.h>
+#include <mission/controller/acs/MultiplicativeKalmanFilter.h>
+#include <mission/controller/acs/Navigation.h>
+#include <mission/controller/acs/SensorProcessing.h>
+#include <mission/controller/acs/control/Detumble.h>
+#include <mission/controller/acs/control/PtgCtrl.h>
+#include <mission/controller/acs/control/SafeCtrl.h>
+#include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
 #include <mission/utility/trace.h>
 
-#include "acs/ActuatorCmd.h"
-#include "acs/Guidance.h"
-#include "acs/MultiplicativeKalmanFilter.h"
-#include "acs/Navigation.h"
-#include "acs/SensorProcessing.h"
-#include "acs/control/Detumble.h"
-#include "acs/control/PtgCtrl.h"
-#include "acs/control/SafeCtrl.h"
-#include "controllerdefinitions/AcsCtrlDefinitions.h"
-
 class AcsController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
  public:
   static constexpr dur_millis_t INIT_DELAY = 500;
@@ -41,9 +40,9 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   void performPointingCtrl();
 
  private:
-  static constexpr double UNIT_QUAT[4] = {0, 0, 0, 1};
-  static constexpr double ZERO_VEC[3] = {0, 0, 0};
-  static constexpr double RW_OFF_TORQUE[4] = {0.0, 0.0, 0.0, 0.0};
+  static constexpr double ZERO_VEC3[3] = {0, 0, 0};
+  static constexpr double ZERO_VEC4[4] = {0, 0, 0, 0};
+  static constexpr double RW_OFF_TORQUE[4] = {0, 0, 0, 0};
   static constexpr int32_t RW_OFF_SPEED[4] = {0, 0, 0, 0};
 
   bool enableHkSets = false;
@@ -70,7 +69,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   bool mekfLost = false;
 
   int32_t cmdSpeedRws[4] = {0, 0, 0, 0};
-  int16_t cmdDipolMtqs[3] = {0, 0, 0};
+  int16_t cmdDipoleMtqs[3] = {0, 0, 0};
 
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
@@ -85,6 +84,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   static const DeviceCommandId_t RESTORE_MEKF_NONFINITE_RECOVERY = 0x2;
 
   static const uint8_t INTERFACE_ID = CLASS_ID::ACS_CTRL;
+  //! [EXPORT] : [COMMENT] File deletion failed and at least one file is still existent.
   static constexpr ReturnValue_t FILE_DELETION_FAILED = MAKE_RETURN_CODE(0);
 
   ReturnValue_t initialize() override;
@@ -105,6 +105,8 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   void modeChanged(Mode_t mode, Submode_t submode);
   void announceMode(bool recursive);
 
+  void safeCtrlFailure(uint8_t mgmFailure, uint8_t sensorFailure);
+
   ReturnValue_t commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
                                  uint16_t dipoleTorqueDuration);
   ReturnValue_t commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
@@ -113,7 +115,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   void updateActuatorCmdData(const int16_t* mtqTargetDipole);
   void updateActuatorCmdData(const double* rwTargetTorque, const int32_t* rwTargetSpeed,
                              const int16_t* mtqTargetDipole);
-  void updateCtrlValData(double errAng);
+  void updateCtrlValData(double errAng, uint8_t safeModeStrat);
   void updateCtrlValData(const double* tgtQuat, const double* errQuat, double errAng,
                          const double* tgtRotRate);
   void disableCtrlValData();
@@ -212,6 +214,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
 
   // Ctrl Values
   acsctrl::CtrlValData ctrlValData;
+  PoolEntry<uint8_t> safeStrat = PoolEntry<uint8_t>();
   PoolEntry<double> tgtQuat = PoolEntry<double>(4);
   PoolEntry<double> errQuat = PoolEntry<double>(4);
   PoolEntry<double> errAng = PoolEntry<double>();

mission/controller/ThermalController.cpp

@@ -20,6 +20,8 @@
 #define LOWER_SYRLINKS_UPPER_LIMITS 0
 #define LOWER_EBAND_UPPER_LIMITS 0
 #define LOWER_PLOC_UPPER_LIMITS 0
+#define LOWER_MGT_UPPER_LIMITS 0
+#define LOWER_RW_UPPER_LIMITS 0
 
 ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater,
                                      const std::atomic_bool& tcsBoardShortUnavailable)
@@ -111,7 +113,7 @@ void ThermalController::performControlOperation() {
       break;
   }
 
-  if (cycles == 50) {
+  if (cycles == 40) {
     bool changedLimits = false;
 #if LOWER_SYRLINKS_UPPER_LIMITS == 1
     changedLimits = true;
@@ -130,9 +132,21 @@ void ThermalController::performControlOperation() {
     hpaLimits.cutOffLimit = 0;
     hpaLimits.opUpperLimit = 0;
     hpaLimits.nopUpperLimit = 0;
+#endif
+#if LOWER_MGT_UPPER_LIMITS == 1
+    changedLimits = true;
+    mgtLimits.cutOffLimit = 0;
+    mgtLimits.opUpperLimit = 0;
+    mgtLimits.nopUpperLimit = 0;
+#endif
+#if LOWER_RW_UPPER_LIMITS == 1
+    changedLimits = true;
+    rwLimits.cutOffLimit = 0;
+    rwLimits.opUpperLimit = 0;
+    rwLimits.nopUpperLimit = 0;
 #endif
     if (changedLimits) {
-      sif::debug << "ThermalController: changing limits" << std::endl;  // TODO: rausschmeissen
+      sif::debug << "ThermalController: changing limits" << std::endl;
     }
   }
 
@@ -161,7 +175,7 @@ void ThermalController::performControlOperation() {
   heaterHandler.getAllSwitchStates(heaterSwitchStateArray);
   {
     PoolReadGuard pg(&heaterInfo);
-    std::memcpy(heaterInfo.heaterSwitchState.value, heaterStates.data(), 8);
+    std::memcpy(heaterInfo.heaterSwitchState.value, heaterSwitchStateArray.data(), 8);
     {
       PoolReadGuard pg2(&currentVecPdu2);
       if (pg.getReadResult() == returnvalue::OK and pg2.getReadResult() == returnvalue::OK) {
@@ -170,26 +184,31 @@ void ThermalController::performControlOperation() {
     }
   }
 
-  if (transitionToOff) {
-    for (const auto& switchState : heaterSwitchStateArray) {
-      if (switchState != HeaterHandler::SwitchState::OFF) {
-        transitionToOffCycles++;
-        // if heater still ON after 10 cycles, switch OFF again
-        if (transitionToOffCycles == 10) {
-          for (uint8_t i = 0; i < heater::Switchers::NUMBER_OF_SWITCHES; i++) {
-            heaterHandler.switchHeater(static_cast<heater::Switchers>(i),
-                                       HeaterHandler::SwitchState::OFF);
-          }
+  cycles++;
+  if (transitionWhenHeatersOff) {
+    bool allSwitchersOff = true;
+    for (size_t idx = 0; idx < heaterSwitchStateArray.size(); idx++) {
+      if (heaterSwitchStateArray[idx] != HeaterHandler::SwitchState::OFF) {
+        allSwitchersOff = false;
+        // if heater still ON after 3 cycles, switch OFF again
+        if (transitionWhenHeatersOffCycles == 3) {
+          heaterHandler.switchHeater(static_cast<heater::Switch>(idx),
+                                     HeaterHandler::SwitchState::OFF);
           triggerEvent(tcsCtrl::HEATER_NOT_OFF_FOR_OFF_MODE);
         }
-        return;
       }
-      setMode(MODE_OFF);
+    }
+    if (allSwitchersOff or transitionWhenHeatersOffCycles == 6) {
+      // Finish the transition
+      transitionWhenHeatersOff = false;
+      resetThermalStates();
+      setMode(targetMode, targetSubmode);
+    } else {
+      transitionWhenHeatersOffCycles++;
     }
   } else if (mode != MODE_OFF and not tcsBrdShortlyUnavailable) {
     performThermalModuleCtrl(heaterSwitchStateArray);
   }
-  cycles++;
 }
 
 ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -292,12 +311,18 @@ LocalPoolDataSetBase* ThermalController::getDataSetHandle(sid_t sid) {
 
 ReturnValue_t ThermalController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                   uint32_t* msToReachTheMode) {
+  if ((mode != MODE_OFF) and (mode != MODE_ON)) {
+    return INVALID_MODE;
+  }
+  if (mode == MODE_ON) {
+    if (submode != SUBMODE_NONE and submode != SUBMODE_NO_HEATER_CTRL) {
+      return HasModesIF::INVALID_SUBMODE;
+    }
+    return returnvalue::OK;
+  }
   if (submode != SUBMODE_NONE) {
     return INVALID_SUBMODE;
   }
-  if ((mode != MODE_OFF) && (mode != MODE_ON) && (mode != MODE_NORMAL)) {
-    return INVALID_MODE;
-  }
   return returnvalue::OK;
 }
 
@@ -976,8 +1001,8 @@ void ThermalController::copyDevices() {
 }
 
 void ThermalController::ctrlAcsBoard() {
-  heater::Switchers switchNr = heater::HEATER_2_ACS_BRD;
-  heater::Switchers redSwitchNr = heater::HEATER_0_OBC_BRD;
+  heater::Switch switchNr = heater::HEATER_2_ACS_BRD;
+  heater::Switch redSwitchNr = heater::HEATER_3_OBC_BRD;
 
   // A side
   thermalComponent = ACS_BOARD;
@@ -1023,7 +1048,9 @@ void ThermalController::ctrlAcsBoard() {
     } else {
       if (chooseHeater(switchNr, redSwitchNr)) {
         if (heaterHandler.getSwitchState(switchNr)) {
-          heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
+          if (submode != SUBMODE_NO_HEATER_CTRL) {
+            heaterSwitchHelper(switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
+          }
         }
       }
     }
@@ -1040,9 +1067,14 @@ void ThermalController::ctrlMgt() {
   sensors[2].first = sensorTemperatures.plpcduHeatspreader.isValid();
   sensors[2].second = sensorTemperatures.plpcduHeatspreader.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, mgtLimits);
+  HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_1_PCDU_PDU, mgtLimits);
   ctrlComponentTemperature(htrCtx);
-  // TODO: trigger special event
+  if (componentAboveUpperLimit and not mgtTooHotFlag) {
+    triggerEvent(tcsCtrl::MGT_OVERHEATING, tempFloatToU32());
+    mgtTooHotFlag = true;
+  } else if (not componentAboveUpperLimit) {
+    mgtTooHotFlag = false;
+  }
 }
 
 void ThermalController::ctrlRw() {
@@ -1174,7 +1206,7 @@ void ThermalController::ctrlIfBoard() {
   sensors[2].first = deviceTemperatures.mgm2SideB.isValid();
   sensors[2].second = deviceTemperatures.mgm2SideB.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, ifBoardLimits);
+  HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_1_PCDU_PDU, ifBoardLimits);
   ctrlComponentTemperature(htrCtx);
   // TODO: special event overheating + could go back to safe mode
 }
@@ -1188,7 +1220,7 @@ void ThermalController::ctrlTcsBoard() {
   sensors[2].first = sensorTemperatures.tmp1075Tcs1.isValid();
   sensors[2].second = sensorTemperatures.tmp1075Tcs1.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, tcsBoardLimits);
+  HeaterContext htrCtx(heater::HEATER_3_OBC_BRD, heater::HEATER_2_ACS_BRD, tcsBoardLimits);
   ctrlComponentTemperature(htrCtx);
   // TODO: special event overheating + could go back to safe mode
 }
@@ -1202,7 +1234,7 @@ void ThermalController::ctrlObc() {
   sensors[2].first = sensorTemperatures.tmp1075Tcs0.isValid();
   sensors[2].second = sensorTemperatures.tmp1075Tcs0.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcLimits);
+  HeaterContext htrCtx(heater::HEATER_3_OBC_BRD, heater::HEATER_2_ACS_BRD, obcLimits);
   ctrlComponentTemperature(htrCtx);
   if (componentAboveUpperLimit and not obcTooHotFlag) {
     triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
@@ -1221,13 +1253,13 @@ void ThermalController::ctrlObcIfBoard() {
   sensors[2].first = sensorTemperatures.tmp1075Tcs1.isValid();
   sensors[2].second = sensorTemperatures.tmp1075Tcs1.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcIfBoardLimits);
+  HeaterContext htrCtx(heater::HEATER_3_OBC_BRD, heater::HEATER_2_ACS_BRD, obcIfBoardLimits);
   ctrlComponentTemperature(htrCtx);
   if (componentAboveUpperLimit and not obcTooHotFlag) {
     triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
     obcTooHotFlag = true;
   } else if (not componentAboveUpperLimit) {
-    obcTooHotFlag = false;  // TODO: !!
+    obcTooHotFlag = false;
   }
 }
 
@@ -1256,7 +1288,7 @@ void ThermalController::ctrlPcduP60Board() {
   sensors[1].first = deviceTemperatures.temp2P60dock.isValid();
   sensors[1].second = deviceTemperatures.temp2P60dock.value;
   numSensors = 2;
-  HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduP60BoardLimits);
+  HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduP60BoardLimits);
   ctrlComponentTemperature(htrCtx);
   if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
     triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
@@ -1268,8 +1300,8 @@ void ThermalController::ctrlPcduP60Board() {
 
 void ThermalController::ctrlPcduAcu() {
   thermalComponent = PCDUACU;
-  heater::Switchers switchNr = heater::HEATER_3_PCDU_PDU;
-  heater::Switchers redSwitchNr = heater::HEATER_2_ACS_BRD;
+  heater::Switch switchNr = heater::HEATER_1_PCDU_PDU;
+  heater::Switch redSwitchNr = heater::HEATER_2_ACS_BRD;
 
   if (chooseHeater(switchNr, redSwitchNr)) {
     bool sensorTempAvailable = true;
@@ -1308,7 +1340,7 @@ void ThermalController::ctrlPcduPdu() {
   sensors[2].first = sensorTemperatures.tmp1075Tcs0.isValid();
   sensors[2].second = sensorTemperatures.tmp1075Tcs0.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduPduLimits);
+  HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduPduLimits);
   ctrlComponentTemperature(htrCtx);
   if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
     triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
@@ -1329,7 +1361,7 @@ void ThermalController::ctrlPlPcduBoard() {
   sensors[3].first = sensorTemperatures.plpcduHeatspreader.isValid();
   sensors[3].second = sensorTemperatures.plpcduHeatspreader.value;
   numSensors = 4;
-  HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, plPcduBoardLimits);
+  HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, plPcduBoardLimits);
   ctrlComponentTemperature(htrCtx);
   tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
 }
@@ -1343,7 +1375,7 @@ void ThermalController::ctrlPlocMissionBoard() {
   sensors[2].first = sensorTemperatures.dacHeatspreader.isValid();
   sensors[2].second = sensorTemperatures.dacHeatspreader.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
+  HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD,
                        plocMissionBoardLimits);
   ctrlComponentTemperature(htrCtx);
   tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
@@ -1358,7 +1390,7 @@ void ThermalController::ctrlPlocProcessingBoard() {
   sensors[2].first = sensorTemperatures.dacHeatspreader.isValid();
   sensors[2].second = sensorTemperatures.dacHeatspreader.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
+  HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD,
                        plocProcessingBoardLimits);
   ctrlComponentTemperature(htrCtx);
   tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
@@ -1373,7 +1405,7 @@ void ThermalController::ctrlDac() {
   sensors[2].first = sensorTemperatures.plocHeatspreader.isValid();
   sensors[2].second = sensorTemperatures.plocHeatspreader.value;
   numSensors = 3;
-  HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD, dacLimits);
+  HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD, dacLimits);
   ctrlComponentTemperature(htrCtx);
   tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
 }
@@ -1557,13 +1589,16 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
 void ThermalController::ctrlComponentTemperature(HeaterContext& htrCtx) {
   if (selectAndReadSensorTemp(htrCtx)) {
     if (chooseHeater(htrCtx.switchNr, htrCtx.redSwitchNr)) {
+      // Core loop for a thermal component, after sensors and heaters were selected.
       checkLimitsAndCtrlHeater(htrCtx);
     }
   } else {
-    // TODO: muss der Heater dann wirklich abgeschalten werden?
+    // No sensors available, so switch the heater off. We can not perform control tasks if we
+    // are blind..
     if (chooseHeater(htrCtx.switchNr, htrCtx.redSwitchNr)) {
-      if (heaterHandler.getSwitchState(htrCtx.switchNr)) {
-        heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
+      if (heaterCtrlAllowed() and
+          (heaterHandler.getSwitchState(htrCtx.switchNr) == HeaterHandler::SwitchState::ON)) {
+        heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
       }
     }
   }
@@ -1593,16 +1628,21 @@ bool ThermalController::selectAndReadSensorTemp(HeaterContext& htrCtx) {
 
   return false;
 }
-bool ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr) {
+bool ThermalController::chooseHeater(heater::Switch& switchNr, heater::Switch redSwitchNr) {
   bool heaterAvailable = true;
 
-  if (heaterHandler.getHealth(switchNr) != HasHealthIF::HEALTHY) {
-    if (heaterHandler.getHealth(redSwitchNr) == HasHealthIF::HEALTHY) {
+  HasHealthIF::HealthState mainHealth = heaterHandler.getHealth(switchNr);
+  HasHealthIF::HealthState redHealth = heaterHandler.getHealth(redSwitchNr);
+  if (mainHealth != HasHealthIF::HEALTHY) {
+    if (redHealth == HasHealthIF::HEALTHY) {
       switchNr = redSwitchNr;
       redSwitchNrInUse = true;
     } else {
       heaterAvailable = false;
-      triggerEvent(tcsCtrl::NO_HEALTHY_HEATER_AVAILABLE, switchNr, redSwitchNr);
+      // Special case: Ground might command/do something with the heaters, so prevent spam.
+      if (not(mainHealth == EXTERNAL_CONTROL and redHealth == EXTERNAL_CONTROL)) {
+        triggerEvent(tcsCtrl::NO_HEALTHY_HEATER_AVAILABLE, switchNr, redSwitchNr);
+      }
     }
   } else {
     redSwitchNrInUse = false;
@@ -1611,15 +1651,18 @@ bool ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switch
 }
 
 void ThermalController::heaterCtrlTempTooHighHandler(HeaterContext& htrCtx, const char* whatLimit) {
+  if (not heaterCtrlAllowed()) {
+    return;
+  }
   if (htrCtx.switchState == HeaterHandler::SwitchState::ON) {
     sif::info << "TCS: Component " << static_cast<int>(thermalComponent) << " too warm, above "
               << whatLimit << ", switching off heater" << std::endl;
-    heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
+    heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
     heaterStates[htrCtx.switchNr].switchTransition = true;
     heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
   }
   if (heaterHandler.getSwitchState(htrCtx.redSwitchNr) == HeaterHandler::SwitchState::ON) {
-    heaterHandler.switchHeater(htrCtx.redSwitchNr, HeaterHandler::SwitchState::OFF);
+    heaterSwitchHelper(htrCtx.redSwitchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
     heaterStates[htrCtx.redSwitchNr].switchTransition = true;
     heaterStates[htrCtx.redSwitchNr].target = HeaterHandler::SwitchState::OFF;
   }
@@ -1634,43 +1677,44 @@ void ThermalController::checkLimitsAndCtrlHeater(HeaterContext& htrCtx) {
   if (heaterStates[htrCtx.switchNr].switchTransition) {
     htrCtx.doHeaterHandling = false;
     heaterCtrlCheckUpperLimits(htrCtx);
-  } else {
-    // Heater off
-    htrCtx.switchState = heaterHandler.getSwitchState(htrCtx.switchNr);
-    if (htrCtx.switchState == HeaterHandler::SwitchState::OFF) {
-      if (sensorTemp < htrCtx.tempLimit.opLowerLimit) {
-        heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::ON);
-        sif::info << "ThermalController::checkLimitsAndCtrlHeater: Heater "
-                  << static_cast<int>(thermalComponent) << " ON" << std::endl;
+    return;
+  }
+
+  htrCtx.switchState = heaterHandler.getSwitchState(htrCtx.switchNr);
+  // Heater off
+  if (htrCtx.switchState == HeaterHandler::SwitchState::OFF) {
+    if (sensorTemp < htrCtx.tempLimit.opLowerLimit and heaterCtrlAllowed()) {
+      sif::info << "TCS: Heater " << static_cast<int>(thermalComponent) << " ON" << std::endl;
+      heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::ON, thermalComponent);
+      heaterStates[htrCtx.switchNr].switchTransition = true;
+      heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::ON;
+    } else {
+      // Even if heater control is now allowed, we can update the state.
+      thermalStates[thermalComponent].heating = false;
+    }
+    heaterCtrlCheckUpperLimits(htrCtx);
+    return;
+  }
+
+  // Heater on
+  if (htrCtx.switchState == HeaterHandler::SwitchState::ON) {
+    if (thermalStates[thermalComponent].heating) {
+      // We are already in a heating cycle, so need to check whether heating task is complete.
+      if (sensorTemp >= htrCtx.tempLimit.opLowerLimit + TEMP_OFFSET and heaterCtrlAllowed()) {
+        sif::info << "TCS: Heater " << static_cast<int>(thermalComponent) << " OFF" << std::endl;
+        heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
         heaterStates[htrCtx.switchNr].switchTransition = true;
-        thermalStates[thermalComponent].heating = true;
-        heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::ON;
-      } else {
-        thermalStates[thermalComponent].heating = false;
+        heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
       }
-      heaterCtrlCheckUpperLimits(htrCtx);
-      // Heater on
-    } else if (heaterHandler.getSwitchState(htrCtx.switchNr) == HeaterHandler::SwitchState::ON) {
-      if (thermalStates[thermalComponent].heating) {
-        // We are already in a heating cycle, so need to check whether heating task is complete.
-        if (sensorTemp >= htrCtx.tempLimit.opLowerLimit + TEMP_OFFSET) {
-          heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
-          sif::info << "ThermalController::checkLimitsAndCtrlHeater: Heater "
-                    << static_cast<int>(thermalComponent) << " OFF" << std::endl;
-          heaterStates[htrCtx.switchNr].switchTransition = true;
-          heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
-          thermalStates[thermalComponent].heating = false;
-        }
-      } else {
-        // This can happen if heater is used as alternative heater (no regular heating cycle), so we
-        // should still check the upper limits.
-        bool tooHighHandlerAlreadyCalled = heaterCtrlCheckUpperLimits(htrCtx);
-        if (sensorTemp >= htrCtx.tempLimit.cutOffLimit) {
-          componentAboveCutOffLimit = true;
-          if (not tooHighHandlerAlreadyCalled) {
-            heaterCtrlTempTooHighHandler(htrCtx, "CutOff-Limit");
-          }
-        }
+      return;
+    }
+    // This can happen if heater is used as alternative heater (no regular heating cycle), so we
+    // should still check the upper limits.
+    bool tooHighHandlerAlreadyCalled = heaterCtrlCheckUpperLimits(htrCtx);
+    if (sensorTemp >= htrCtx.tempLimit.cutOffLimit) {
+      componentAboveCutOffLimit = true;
+      if (not tooHighHandlerAlreadyCalled) {
+        heaterCtrlTempTooHighHandler(htrCtx, "CutOff-Limit");
       }
     }
   }
@@ -1702,8 +1746,8 @@ void ThermalController::resetSensorsArray() {
   }
   thermalComponent = NONE;
 }
+
 void ThermalController::heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates) {
-  // TODO: Test
   for (unsigned i = 0; i < 7; i++) {
     if (heaterStates[i].switchTransition) {
       if (currentHeaterStates[i] == heaterStates[i].target) {
@@ -1727,11 +1771,12 @@ uint32_t ThermalController::tempFloatToU32() const {
   return tempRaw;
 }
 
-void ThermalController::setMode(Mode_t mode) {
+void ThermalController::setMode(Mode_t mode, Submode_t submode) {
   if (mode == MODE_OFF) {
-    transitionToOff = false;
+    transitionWhenHeatersOff = false;
   }
   this->mode = mode;
+  this->submode = submode;
   modeHelper.modeChanged(mode, submode);
   announceMode(false);
 }
@@ -1746,6 +1791,43 @@ bool ThermalController::tooHotHandler(object_id_t object, bool& oneShotFlag) {
   return false;
 }
 
+bool ThermalController::heaterCtrlAllowed() const { return submode != SUBMODE_NO_HEATER_CTRL; }
+
+void ThermalController::resetThermalStates() {
+  for (auto& thermalState : thermalStates) {
+    thermalState.heating = false;
+  }
+}
+
+void ThermalController::heaterSwitchHelper(heater::Switch switchNr,
+                                           HeaterHandler::SwitchState state,
+                                           unsigned componentIdx) {
+  timeval currentTime;
+  Clock::getClockMonotonic(&currentTime);
+  if (state == HeaterHandler::SwitchState::ON) {
+    heaterHandler.switchHeater(switchNr, state);
+    thermalStates[componentIdx].heating = true;
+    thermalStates[componentIdx].heaterStartTime = currentTime.tv_sec;
+  } else {
+    heaterHandler.switchHeater(switchNr, state);
+    thermalStates[componentIdx].heating = false;
+    thermalStates[componentIdx].heaterEndTime = currentTime.tv_sec;
+  }
+}
+
+void ThermalController::heaterSwitchHelperAllOff() {
+  timeval currentTime;
+  Clock::getClockMonotonic(&currentTime);
+  size_t idx = 0;
+  for (; idx < heater::Switch::NUMBER_OF_SWITCHES; idx++) {
+    heaterHandler.switchHeater(static_cast<heater::Switch>(idx), HeaterHandler::SwitchState::OFF);
+  }
+  for (idx = 0; idx < thermalStates.size(); idx++) {
+    thermalStates[idx].heating = false;
+    thermalStates[idx].heaterEndTime = currentTime.tv_sec;
+  }
+}
+
 void ThermalController::tooHotHandlerWhichClearsOneShotFlag(object_id_t object, bool& oneShotFlag) {
   // Clear the one shot flag is the component is in acceptable temperature range.
   if (not tooHotHandler(object, oneShotFlag) and not componentAboveUpperLimit) {
@@ -1755,14 +1837,15 @@ void ThermalController::tooHotHandlerWhichClearsOneShotFlag(object_id_t object,
 
 void ThermalController::startTransition(Mode_t mode_, Submode_t submode_) {
   triggerEvent(CHANGING_MODE, mode_, submode_);
-  if (mode_ == MODE_OFF) {
-    for (uint8_t i = 0; i < heater::Switchers::NUMBER_OF_SWITCHES; i++) {
-      heaterHandler.switchHeater(static_cast<heater::Switchers>(i),
-                                 HeaterHandler::SwitchState::OFF);
-    }
-    transitionToOff = true;
-    transitionToOffCycles = 0;
+  // For MODE_OFF and the no heater control submode, we command all switches to off before
+  // completing the transition. This ensures a consistent state when commanding these modes.
+  if ((mode_ == MODE_OFF) or ((mode_ == MODE_ON) and (submode_ == SUBMODE_NO_HEATER_CTRL))) {
+    heaterSwitchHelperAllOff();
+    transitionWhenHeatersOff = true;
+    targetMode = mode_;
+    targetSubmode = submode_;
+    transitionWhenHeatersOffCycles = 0;
   } else {
-    setMode(mode_);
+    setMode(mode_, submode_);
   }
 }

mission/controller/ThermalController.h

@@ -48,8 +48,13 @@ struct TempLimits {
 
 struct ThermalState {
   uint8_t errorCounter;
-  bool heating;
-  uint32_t heaterStartTime;
+  // Is heating on for that thermal module?
+  bool heating = false;
+  heater::Switch heaterSwitch = heater::Switch::NUMBER_OF_SWITCHES;
+  // Heater start time and end times as UNIX seconds. Please note that these times will be updated
+  // when a switch command is sent, with no guarantess that the heater actually went on.
+  uint32_t heaterStartTime = 0;
+  uint32_t heaterEndTime = 0;
 };
 
 struct HeaterState {
@@ -90,6 +95,8 @@ enum ThermalComponents : uint8_t {
 
 class ThermalController : public ExtendedControllerBase {
  public:
+  static constexpr uint8_t SUBMODE_NO_HEATER_CTRL = 1;
+
   static const uint16_t INVALID_TEMPERATURE = 999;
   static const uint8_t NUMBER_OF_SENSORS = 16;
   static constexpr int16_t SANITY_LIMIT_LOWER_TEMP = -80;
@@ -103,13 +110,13 @@ class ThermalController : public ExtendedControllerBase {
  protected:
   struct HeaterContext {
    public:
-    HeaterContext(heater::Switchers switchNr, heater::Switchers redundantSwitchNr,
+    HeaterContext(heater::Switch switchNr, heater::Switch redundantSwitchNr,
                   const TempLimits& tempLimit)
         : switchNr(switchNr), redSwitchNr(redundantSwitchNr), tempLimit(tempLimit) {}
     bool doHeaterHandling = true;
-    heater::Switchers switchNr;
+    heater::Switch switchNr;
     HeaterHandler::SwitchState switchState = HeaterHandler::SwitchState::OFF;
-    heater::Switchers redSwitchNr;
+    heater::Switch redSwitchNr;
     const TempLimits& tempLimit;
   };
 
@@ -260,14 +267,17 @@ class ThermalController : public ExtendedControllerBase {
   bool pcduSystemTooHotFlag = false;
   bool syrlinksTooHotFlag = false;
   bool obcTooHotFlag = false;
+  bool mgtTooHotFlag = false;
   bool strTooHotFlag = false;
   bool rwTooHotFlag = false;
 
-  bool transitionToOff = false;
-  uint32_t transitionToOffCycles = 0;
+  bool transitionWhenHeatersOff = false;
+  uint32_t transitionWhenHeatersOffCycles = 0;
+  Mode_t targetMode = MODE_OFF;
+  Submode_t targetSubmode = SUBMODE_NONE;
   uint32_t cycles = 0;
-  std::array<ThermalState, 30> thermalStates{};
-  std::array<HeaterState, 7> heaterStates{};
+  std::array<ThermalState, ThermalComponents::NUM_ENTRIES> thermalStates{};
+  std::array<HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
 
   // Initial delay to make sure all pool variables have been initialized their owners.
   // Also, wait for system initialization to complete.
@@ -292,6 +302,9 @@ class ThermalController : public ExtendedControllerBase {
 
   void startTransition(Mode_t mode, Submode_t submode) override;
 
+  bool heaterCtrlAllowed() const;
+  void resetThermalStates();
+
   void resetSensorsArray();
   void copySensors();
   void copySus();
@@ -302,9 +315,13 @@ class ThermalController : public ExtendedControllerBase {
   bool heaterCtrlCheckUpperLimits(HeaterContext& heaterContext);
   void heaterCtrlTempTooHighHandler(HeaterContext& heaterContext, const char* whatLimit);
 
-  bool chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr);
+  bool chooseHeater(heater::Switch& switchNr, heater::Switch redSwitchNr);
   bool selectAndReadSensorTemp(HeaterContext& htrCtx);
 
+  void heaterSwitchHelperAllOff();
+  void heaterSwitchHelper(heater::Switch switchNr, HeaterHandler::SwitchState state,
+                          unsigned componentIdx);
+
   void ctrlAcsBoard();
   void ctrlMgt();
   void ctrlRw();
@@ -329,7 +346,7 @@ class ThermalController : public ExtendedControllerBase {
   void ctrlMpa();
   void ctrlScexBoard();
   void heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates);
-  void setMode(Mode_t mode);
+  void setMode(Mode_t mode, Submode_t submode);
   uint32_t tempFloatToU32() const;
   bool tooHotHandler(object_id_t object, bool& oneShotFlag);
   void tooHotHandlerWhichClearsOneShotFlag(object_id_t object, bool& oneShotFlag);

mission/controller/acs/AcsParameters.cpp

@@ -33,18 +33,15 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
     case 0x2:  // InertiaEIVE
       switch (parameterId) {
         case 0x0:
-          parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrix);
-          break;
-        case 0x1:
           parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixDeployed);
           break;
-        case 0x2:
+        case 0x1:
           parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixUndeployed);
           break;
-        case 0x3:
+        case 0x2:
           parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixPanel1);
           break;
-        case 0x4:
+        case 0x3:
           parameterWrapper->setMatrix(inertiaEIVE.inertiaMatrixPanel3);
           break;
         default:
@@ -107,6 +104,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0x11:
           parameterWrapper->setVector(mgmHandlingParameters.mgm4variance);
           break;
+        case 0x12:
+          parameterWrapper->set(mgmHandlingParameters.mgmDerivativeFilterWeight);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -221,6 +221,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0x23:
           parameterWrapper->setMatrix(susHandlingParameters.sus11coeffBeta);
           break;
+        case 0x24:
+          parameterWrapper->set(susHandlingParameters.susBrightnessThreshold);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -260,6 +263,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0xA:
           parameterWrapper->set(gyrHandlingParameters.preferAdis);
           break;
+        case 0xB:
+          parameterWrapper->set(gyrHandlingParameters.gyrFilterWeight);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -287,6 +293,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0x6:
           parameterWrapper->set(rwHandlingParameters.rampTime);
           break;
+        case 0x7:
+          parameterWrapper->set(rwHandlingParameters.multipleRwInvalidTimeout);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -312,7 +321,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->setMatrix(rwMatrices.without4);
           break;
         case 0x6:
-          parameterWrapper->setVector(rwMatrices.nullspace);
+          parameterWrapper->setVector(rwMatrices.nullspaceVector);
           break;
         default:
           return INVALID_IDENTIFIER_ID;
@@ -321,28 +330,34 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
     case (0x8):  // SafeModeControllerParameters
       switch (parameterId) {
         case 0x0:
-          parameterWrapper->set(safeModeControllerParameters.k_rate_mekf);
+          parameterWrapper->set(safeModeControllerParameters.k_orthoMekf);
           break;
         case 0x1:
-          parameterWrapper->set(safeModeControllerParameters.k_align_mekf);
+          parameterWrapper->set(safeModeControllerParameters.k_alignMekf);
           break;
         case 0x2:
-          parameterWrapper->set(safeModeControllerParameters.k_rate_no_mekf);
+          parameterWrapper->set(safeModeControllerParameters.k_parallelMekf);
           break;
         case 0x3:
-          parameterWrapper->set(safeModeControllerParameters.k_align_no_mekf);
+          parameterWrapper->set(safeModeControllerParameters.k_orthoNonMekf);
           break;
         case 0x4:
-          parameterWrapper->set(safeModeControllerParameters.sunMagAngleMin);
+          parameterWrapper->set(safeModeControllerParameters.k_alignNonMekf);
           break;
         case 0x5:
-          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDirLeop);
+          parameterWrapper->set(safeModeControllerParameters.k_parallelNonMekf);
           break;
         case 0x6:
-          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDir);
+          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDirLeop);
           break;
         case 0x7:
-          parameterWrapper->setVector(safeModeControllerParameters.satRateRef);
+          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDir);
+          break;
+        case 0x8:
+          parameterWrapper->set(safeModeControllerParameters.useMekf);
+          break;
+        case 0x9:
+          parameterWrapper->set(safeModeControllerParameters.dampingDuringEclipse);
           break;
         default:
           return INVALID_IDENTIFIER_ID;
@@ -366,18 +381,20 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(idleModeControllerParameters.gainNullspace);
           break;
         case 0x5:
-          parameterWrapper->setVector(idleModeControllerParameters.desatMomentumRef);
+          parameterWrapper->set(idleModeControllerParameters.nullspaceSpeed);
           break;
         case 0x6:
-          parameterWrapper->set(idleModeControllerParameters.deSatGainFactor);
+          parameterWrapper->setVector(idleModeControllerParameters.desatMomentumRef);
           break;
         case 0x7:
-          parameterWrapper->set(idleModeControllerParameters.desatOn);
+          parameterWrapper->set(idleModeControllerParameters.deSatGainFactor);
           break;
         case 0x8:
+          parameterWrapper->set(idleModeControllerParameters.desatOn);
+          break;
+        case 0x9:
           parameterWrapper->set(idleModeControllerParameters.enableAntiStiction);
           break;
-
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -400,48 +417,51 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(targetModeControllerParameters.gainNullspace);
           break;
         case 0x5:
-          parameterWrapper->setVector(targetModeControllerParameters.desatMomentumRef);
+          parameterWrapper->set(targetModeControllerParameters.nullspaceSpeed);
           break;
         case 0x6:
-          parameterWrapper->set(targetModeControllerParameters.deSatGainFactor);
+          parameterWrapper->setVector(targetModeControllerParameters.desatMomentumRef);
           break;
         case 0x7:
-          parameterWrapper->set(targetModeControllerParameters.desatOn);
+          parameterWrapper->set(targetModeControllerParameters.deSatGainFactor);
           break;
         case 0x8:
-          parameterWrapper->set(targetModeControllerParameters.enableAntiStiction);
+          parameterWrapper->set(targetModeControllerParameters.desatOn);
           break;
         case 0x9:
-          parameterWrapper->setVector(targetModeControllerParameters.refDirection);
+          parameterWrapper->set(targetModeControllerParameters.enableAntiStiction);
           break;
         case 0xA:
-          parameterWrapper->setVector(targetModeControllerParameters.refRotRate);
+          parameterWrapper->setVector(targetModeControllerParameters.refDirection);
           break;
         case 0xB:
-          parameterWrapper->setVector(targetModeControllerParameters.quatRef);
+          parameterWrapper->setVector(targetModeControllerParameters.refRotRate);
           break;
         case 0xC:
-          parameterWrapper->set(targetModeControllerParameters.timeElapsedMax);
+          parameterWrapper->setVector(targetModeControllerParameters.quatRef);
           break;
         case 0xD:
-          parameterWrapper->set(targetModeControllerParameters.latitudeTgt);
+          parameterWrapper->set(targetModeControllerParameters.timeElapsedMax);
           break;
         case 0xE:
-          parameterWrapper->set(targetModeControllerParameters.longitudeTgt);
+          parameterWrapper->set(targetModeControllerParameters.latitudeTgt);
           break;
         case 0xF:
-          parameterWrapper->set(targetModeControllerParameters.altitudeTgt);
+          parameterWrapper->set(targetModeControllerParameters.longitudeTgt);
           break;
         case 0x10:
-          parameterWrapper->set(targetModeControllerParameters.avoidBlindStr);
+          parameterWrapper->set(targetModeControllerParameters.altitudeTgt);
           break;
         case 0x11:
-          parameterWrapper->set(targetModeControllerParameters.blindAvoidStart);
+          parameterWrapper->set(targetModeControllerParameters.avoidBlindStr);
           break;
         case 0x12:
-          parameterWrapper->set(targetModeControllerParameters.blindAvoidStop);
+          parameterWrapper->set(targetModeControllerParameters.blindAvoidStart);
           break;
         case 0x13:
+          parameterWrapper->set(targetModeControllerParameters.blindAvoidStop);
+          break;
+        case 0x14:
           parameterWrapper->set(targetModeControllerParameters.blindRotRate);
           break;
         default:
@@ -466,30 +486,33 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(gsTargetModeControllerParameters.gainNullspace);
           break;
         case 0x5:
-          parameterWrapper->setVector(gsTargetModeControllerParameters.desatMomentumRef);
+          parameterWrapper->set(gsTargetModeControllerParameters.nullspaceSpeed);
           break;
         case 0x6:
-          parameterWrapper->set(gsTargetModeControllerParameters.deSatGainFactor);
+          parameterWrapper->setVector(gsTargetModeControllerParameters.desatMomentumRef);
           break;
         case 0x7:
-          parameterWrapper->set(gsTargetModeControllerParameters.desatOn);
+          parameterWrapper->set(gsTargetModeControllerParameters.deSatGainFactor);
           break;
         case 0x8:
-          parameterWrapper->set(gsTargetModeControllerParameters.enableAntiStiction);
+          parameterWrapper->set(gsTargetModeControllerParameters.desatOn);
           break;
         case 0x9:
-          parameterWrapper->setVector(gsTargetModeControllerParameters.refDirection);
+          parameterWrapper->set(gsTargetModeControllerParameters.enableAntiStiction);
           break;
         case 0xA:
-          parameterWrapper->set(gsTargetModeControllerParameters.timeElapsedMax);
+          parameterWrapper->setVector(gsTargetModeControllerParameters.refDirection);
           break;
         case 0xB:
-          parameterWrapper->set(gsTargetModeControllerParameters.latitudeTgt);
+          parameterWrapper->set(gsTargetModeControllerParameters.timeElapsedMax);
           break;
         case 0xC:
-          parameterWrapper->set(gsTargetModeControllerParameters.longitudeTgt);
+          parameterWrapper->set(gsTargetModeControllerParameters.latitudeTgt);
           break;
         case 0xD:
+          parameterWrapper->set(gsTargetModeControllerParameters.longitudeTgt);
+          break;
+        case 0xE:
           parameterWrapper->set(gsTargetModeControllerParameters.altitudeTgt);
           break;
         default:
@@ -514,24 +537,30 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(nadirModeControllerParameters.gainNullspace);
           break;
         case 0x5:
-          parameterWrapper->setVector(nadirModeControllerParameters.desatMomentumRef);
+          parameterWrapper->set(nadirModeControllerParameters.nullspaceSpeed);
           break;
         case 0x6:
-          parameterWrapper->set(nadirModeControllerParameters.deSatGainFactor);
+          parameterWrapper->setVector(nadirModeControllerParameters.desatMomentumRef);
           break;
         case 0x7:
-          parameterWrapper->set(nadirModeControllerParameters.desatOn);
+          parameterWrapper->set(nadirModeControllerParameters.deSatGainFactor);
           break;
         case 0x8:
-          parameterWrapper->set(nadirModeControllerParameters.enableAntiStiction);
+          parameterWrapper->set(nadirModeControllerParameters.desatOn);
           break;
         case 0x9:
-          parameterWrapper->setVector(nadirModeControllerParameters.refDirection);
+          parameterWrapper->set(nadirModeControllerParameters.enableAntiStiction);
           break;
         case 0xA:
+          parameterWrapper->setVector(nadirModeControllerParameters.refDirection);
+          break;
+        case 0xB:
           parameterWrapper->setVector(nadirModeControllerParameters.quatRef);
           break;
         case 0xC:
+          parameterWrapper->setVector(nadirModeControllerParameters.refRotRate);
+          break;
+        case 0xD:
           parameterWrapper->set(nadirModeControllerParameters.timeElapsedMax);
           break;
         default:
@@ -556,21 +585,24 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(inertialModeControllerParameters.gainNullspace);
           break;
         case 0x5:
-          parameterWrapper->setVector(inertialModeControllerParameters.desatMomentumRef);
+          parameterWrapper->set(inertialModeControllerParameters.nullspaceSpeed);
           break;
         case 0x6:
-          parameterWrapper->set(inertialModeControllerParameters.deSatGainFactor);
+          parameterWrapper->setVector(inertialModeControllerParameters.desatMomentumRef);
           break;
         case 0x7:
-          parameterWrapper->set(inertialModeControllerParameters.desatOn);
+          parameterWrapper->set(inertialModeControllerParameters.deSatGainFactor);
           break;
         case 0x8:
-          parameterWrapper->set(inertialModeControllerParameters.enableAntiStiction);
+          parameterWrapper->set(inertialModeControllerParameters.desatOn);
           break;
         case 0x9:
-          parameterWrapper->setVector(inertialModeControllerParameters.tgtQuat);
+          parameterWrapper->set(inertialModeControllerParameters.enableAntiStiction);
           break;
         case 0xA:
+          parameterWrapper->setVector(inertialModeControllerParameters.tgtQuat);
+          break;
+        case 0xB:
           parameterWrapper->setVector(inertialModeControllerParameters.refRotRate);
           break;
         case 0xC:
@@ -682,7 +714,7 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->setMatrix(magnetorquerParameter.inverseAlignment);
           break;
         case 0x5:
-          parameterWrapper->set(magnetorquerParameter.dipolMax);
+          parameterWrapper->set(magnetorquerParameter.dipoleMax);
           break;
         case 0x6:
           parameterWrapper->set(magnetorquerParameter.torqueDuration);
@@ -703,7 +735,13 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
           parameterWrapper->set(detumbleParameter.omegaDetumbleEnd);
           break;
         case 0x3:
-          parameterWrapper->set(detumbleParameter.gainD);
+          parameterWrapper->set(detumbleParameter.gainBdot);
+          break;
+        case 0x4:
+          parameterWrapper->set(detumbleParameter.gainFull);
+          break;
+        case 0x5:
+          parameterWrapper->set(detumbleParameter.useFullDetumbleLaw);
           break;
         default:
           return INVALID_IDENTIFIER_ID;